home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termARexxCommands.c < prev    next >
C/C++ Source or Header  |  1995-07-04  |  100KB  |  5,822 lines
  1. /*
  2. **    termARexxCommands.c
  3. **
  4. **    ARexx interface command support routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termARexxGlobal.h"
  11.  
  12.     /* Number of bytes already processed by ScanNodeFilter(). */
  13.  
  14. STATIC LONG WaitCount = 0;
  15.  
  16.     /* Cheapo shortcuts ;-) */
  17.  
  18. #define Args    Pkt -> Array
  19. #define Results    Pkt -> Results
  20.  
  21.     /* ScanNodeFilter():
  22.      *
  23.      *    Scan memory for a certain sequence.
  24.      */
  25.  
  26. STATIC STRPTR __regargs
  27. ScanNodeFilter(register STRPTR Data,register LONG Size,register struct WaitNode *Node,LONG *Position)
  28. {
  29.     register UBYTE c,Mask;
  30.  
  31.     *Position = 0;
  32.  
  33.     if(Config -> SerialConfig -> StripBit8)
  34.         Mask = 0x7F;
  35.     else
  36.         Mask = 0xFF;
  37.  
  38.     if(Node)
  39.     {
  40.         do
  41.         {
  42.             (*Position)++;
  43.  
  44.             if(c = ToUpper((*Data++) & Mask))
  45.             {
  46.                 register BYTE MatchMade;
  47.  
  48.                 do
  49.                 {
  50.                     MatchMade = FALSE;
  51.  
  52.                     if(Node -> Count == WaitCount)
  53.                     {
  54.                         if(c == (Node -> Node . ln_Name[WaitCount] & Mask))
  55.                         {
  56.                             MatchMade = TRUE;
  57.  
  58.                             if(!Node -> Node . ln_Name[++Node -> Count])
  59.                             {
  60.                                 if(Node -> ResponseLen)
  61.                                 {
  62.                                     SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  63.  
  64.                                     Node -> Count = 0;
  65.                                 }
  66.                                 else
  67.                                     return(Node -> Node . ln_Name);
  68.                             }
  69.                         }
  70.                     }
  71.  
  72.                     if(MatchMade)
  73.                         WaitCount++;
  74.                     else
  75.                     {
  76.                         if(WaitCount)
  77.                         {
  78.                             WaitCount = 0;
  79.  
  80.                             Node -> Count = 0;
  81.                         }
  82.                         else
  83.                             break;
  84.                     }
  85.                 }
  86.                 while(!WaitCount);
  87.             }
  88.         }
  89.         while(--Size);
  90.     }
  91.     else
  92.     {
  93.         do
  94.         {
  95.             (*Position)++;
  96.  
  97.             if(c = ToUpper((*Data++) & Mask))
  98.             {
  99.                 register BYTE MatchMade;
  100.  
  101.                 do
  102.                 {
  103.                     MatchMade = FALSE;
  104.  
  105.                     Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  106.  
  107.                     while(Node -> Node . ln_Succ)
  108.                     {
  109.                         if(Node -> Count == WaitCount)
  110.                         {
  111.                             if(c == (Node -> Node . ln_Name[WaitCount] & Mask))
  112.                             {
  113.                                 Node -> Count++;
  114.  
  115.                                 MatchMade = TRUE;
  116.  
  117.                                 if(!Node -> Node . ln_Name[Node -> Count])
  118.                                 {
  119.                                     if(Node -> ResponseLen)
  120.                                     {
  121.                                         SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  122.  
  123.                                         Node -> Count = 0;
  124.                                     }
  125.                                     else
  126.                                         return(Node -> Node . ln_Name);
  127.                                 }
  128.                             }
  129.                         }
  130.  
  131.                         Node = (struct WaitNode *)Node -> Node . ln_Succ;
  132.                     }
  133.  
  134.                     if(MatchMade)
  135.                         WaitCount++;
  136.                     else
  137.                     {
  138.                         if(WaitCount)
  139.                         {
  140.                             WaitCount = 0;
  141.  
  142.                             Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  143.  
  144.                             while(Node -> Node . ln_Succ)
  145.                             {
  146.                                 Node -> Count = 0;
  147.  
  148.                                 Node = (struct WaitNode *)Node -> Node . ln_Succ;
  149.                             }
  150.                         }
  151.                         else
  152.                             break;
  153.                     }
  154.                 }
  155.                 while(!WaitCount);
  156.             }
  157.         }
  158.         while(--Size);
  159.     }
  160.  
  161.     return(NULL);
  162. }
  163.  
  164. STRPTR
  165. RexxActivate(struct RexxPkt *Pkt)
  166. {
  167.     if(Window)
  168.         BumpWindow(Window);
  169.     else
  170.         Signal(ThisProcess,SIGBREAKF_CTRL_F);
  171.  
  172.     return(NULL);
  173. }
  174.  
  175. STRPTR
  176. RexxAdd(struct RexxPkt *Pkt)
  177. {
  178.     enum    {    ARG_ADD_FROM,ARG_ADD_BEFORE,ARG_ADD_AFTER,ARG_ADD_RESPONSE,
  179.             ARG_ADD_COMMAND,ARG_ADD_PHONEENTRY,ARG_ADD_NAME };
  180.  
  181.     WORD ListIndex;
  182.  
  183.     if((ListIndex = ToList(Args[ARG_ADD_FROM])) != -1)
  184.     {
  185.         struct GenericList    *List = GenericListTable[ListIndex];
  186.         BYTE             AddMode;
  187.  
  188.         if(Args[ARG_ADD_BEFORE])
  189.             AddMode = ADD_GLIST_BEFORE;
  190.         else
  191.         {
  192.             if(Args[ARG_ADD_AFTER])
  193.                 AddMode = ADD_GLIST_BEHIND;
  194.             else
  195.                 AddMode = ADD_GLIST_BOTTOM;
  196.         }
  197.  
  198.         if(ListIndex == GLIST_DIAL)
  199.         {
  200.             if(Args[ARG_ADD_PHONEENTRY])
  201.             {
  202.                 if(!IsNumeric(Args[ARG_ADD_PHONEENTRY]))
  203.                 {
  204.                     STRPTR Buffer;
  205.  
  206.                     if(Buffer = CreateMatchBuffer(Args[ARG_ADD_PHONEENTRY]))
  207.                     {
  208.                         struct DialNode    *Node;
  209.                         LONG         i;
  210.                         BOOL         GotIt = FALSE;
  211.  
  212.                         for(i = 0 ; i < NumPhoneEntries ; i++)
  213.                         {
  214.                             if(MatchBuffer(Buffer,Phonebook[i] -> Header -> Name))
  215.                             {
  216.                                 if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),""))
  217.                                 {
  218.                                     Node -> Entry = Phonebook[i];
  219.  
  220.                                     AddGenericListNode(List,(struct Node *)Node,AddMode);
  221.  
  222.                                     GotIt = TRUE;
  223.                                 }
  224.                                 else
  225.                                 {
  226.                                     Results[0] = RC_ERROR;
  227.                                     Results[1] = ERROR_NO_FREE_STORE;
  228.  
  229.                                     break;
  230.                                 }
  231.                             }
  232.                         }
  233.  
  234.                         if(!GotIt && Results[0] != RC_ERROR)
  235.                         {
  236.                             Results[0] = RC_ERROR;
  237.                             Results[1] = ERROR_OBJECT_NOT_FOUND;
  238.                         }
  239.  
  240.                         DeleteMatchBuffer(Buffer);
  241.                     }
  242.                     else
  243.                     {
  244.                         Results[0] = RC_ERROR;
  245.                         Results[1] = ERROR_NO_FREE_STORE;
  246.                     }
  247.                 }
  248.                 else
  249.                 {
  250.                     LONG Index = Atol(Args[ARG_ADD_PHONEENTRY]);
  251.  
  252.                     if(Index < 0 || Index > NumPhoneEntries)
  253.                     {
  254.                         Results[0] = RC_ERROR;
  255.                         Results[1] = TERMERROR_INDEX_OUT_OF_RANGE;
  256.                     }
  257.                     else
  258.                     {
  259.                         struct DialNode    *Node;
  260.  
  261.                         if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),""))
  262.                         {
  263.                             Node -> Entry = Phonebook[Index];
  264.  
  265.                             AddGenericListNode(List,(struct Node *)Node,AddMode);
  266.                         }
  267.                         else
  268.                         {
  269.                             Results[0] = RC_ERROR;
  270.                             Results[1] = ERROR_NO_FREE_STORE;
  271.                         }
  272.                     }
  273.                 }
  274.             }
  275.             else
  276.             {
  277.                 if(Args[ARG_ADD_NAME])
  278.                 {
  279.                     struct Node *Node;
  280.  
  281.                     if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  282.                         AddGenericListNode(List,Node,AddMode);
  283.                     else
  284.                     {
  285.                         Results[0] = RC_ERROR;
  286.                         Results[1] = ERROR_NO_FREE_STORE;
  287.                     }
  288.                 }
  289.             }
  290.         }
  291.         else
  292.         {
  293.             if(ListIndex == GLIST_WAIT)
  294.             {
  295.                 STRPTR    Response;
  296.                 LONG    ResponseLen;
  297.  
  298.                 if(Args[ARG_ADD_RESPONSE])
  299.                 {
  300.                     Response    = Args[ARG_ADD_RESPONSE];
  301.                     ResponseLen    = strlen(Response);
  302.                 }
  303.                 else
  304.                 {
  305.                     Response    = NULL;
  306.                     ResponseLen    = 0;
  307.                 }
  308.  
  309.                 if(Args[ARG_ADD_NAME])
  310.                 {
  311.                     struct WaitNode *Node;
  312.  
  313.                     if(Node = (struct WaitNode *)CreateGenericListNode(sizeof(struct WaitNode) + ResponseLen + 1,Args[ARG_ADD_NAME]))
  314.                     {
  315.                         WORD i,Len;
  316.  
  317.                         Len = TranslateString(Node -> Node . ln_Name,Node -> Node . ln_Name);
  318.  
  319.                         Node -> Node . ln_Name[Len] = 0;
  320.  
  321.                         for(i = 0 ; i < Len ; i++)
  322.                             Node -> Node . ln_Name[i] = ToUpper(Node -> Node . ln_Name[i]);
  323.  
  324.                         if(Response && ResponseLen)
  325.                         {
  326.                             Node -> Response = &Node -> Node . ln_Name[Len + 1];
  327.  
  328.                             strcpy(Node -> Response,Response);
  329.  
  330.                             Node -> ResponseLen = TranslateString(Node -> Response,Node -> Response);
  331.                         }
  332.                         else
  333.                             Node -> ResponseLen = 0;
  334.  
  335.                         AddGenericListNode(List,Node,AddMode);
  336.                     }
  337.                     else
  338.                     {
  339.                         Results[0] = RC_ERROR;
  340.                         Results[1] = ERROR_NO_FREE_STORE;
  341.                     }
  342.                 }
  343.                 else
  344.                 {
  345.                     Results[0] = RC_ERROR;
  346.                     Results[1] = ERROR_REQUIRED_ARG_MISSING;
  347.                 }
  348.             }
  349.             else
  350.             {
  351.                 if(ListIndex == GLIST_TRAP)
  352.                 {
  353.                     if(!Args[ARG_ADD_NAME] || !Args[ARG_ADD_COMMAND])
  354.                     {
  355.                         struct TrapNode    *Node;
  356.                         UBYTE         LocalBuffer[256];
  357.                         LONG         NameLen;
  358.  
  359.                         if(strlen(Args[ARG_ADD_NAME]) > 255)
  360.                             Args[ARG_ADD_NAME][255] = 0;
  361.  
  362.                         NameLen = TranslateString(Args[ARG_ADD_NAME],LocalBuffer);
  363.  
  364.                         if(Node = (struct TrapNode *)AllocVecPooled(sizeof(struct TrapNode) + strlen(Args[ARG_ADD_NAME]) + 1 + NameLen + strlen(Args[ARG_ADD_COMMAND]) + 1,MEMF_ANY))
  365.                         {
  366.                             STRPTR String = Node -> Node . ln_Name = (STRPTR)(Node + 1);
  367.  
  368.                             strcpy(String,Args[ARG_ADD_NAME]);
  369.  
  370.                             String += strlen(String) + 1;
  371.  
  372.                             Node -> Sequence = String;
  373.  
  374.                             CopyMem(LocalBuffer,String,NameLen);
  375.  
  376.                             String += NameLen;
  377.  
  378.                             Node -> Command = String;
  379.  
  380.                             strcpy(String,Args[ARG_ADD_COMMAND]);
  381.  
  382.                             Node -> SequenceLen = NameLen;
  383.                             Node -> Count = 0;
  384.  
  385.                             AddGenericListNode(List,Node,AddMode);
  386.                         }
  387.                         else
  388.                         {
  389.                             Results[0] = RC_ERROR;
  390.                             Results[1] = ERROR_NO_FREE_STORE;
  391.                         }
  392.                     }
  393.                     else
  394.                     {
  395.                         Results[0] = RC_ERROR;
  396.                         Results[1] = ERROR_REQUIRED_ARG_MISSING;
  397.                     }
  398.                 }
  399.                 else
  400.                 {
  401.                     if(Args[ARG_ADD_NAME])
  402.                     {
  403.                         struct Node *Node;
  404.  
  405.                         if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  406.                             AddGenericListNode(List,Node,AddMode);
  407.                         else
  408.                         {
  409.                             Results[0] = RC_ERROR;
  410.                             Results[1] = ERROR_NO_FREE_STORE;
  411.                         }
  412.                     }
  413.                     else
  414.                     {
  415.                         Results[0] = RC_ERROR;
  416.                         Results[1] = TERMERROR_WRONG_LIST;
  417.                     }
  418.                 }
  419.             }
  420.         }
  421.     }
  422.     else
  423.     {
  424.         Results[0] = RC_ERROR;
  425.         Results[1] = TERMERROR_UNKNOWN_LIST;
  426.     }
  427.  
  428.     return(NULL);
  429. }
  430.  
  431. STRPTR
  432. RexxBaud(struct RexxPkt *Pkt)
  433. {
  434.     enum    {    ARG_BAUD_RATE };
  435.  
  436.     LONG Rate = *(LONG *)Args[ARG_BAUD_RATE],Min = MILLION,Diff,Index;
  437.     WORD i;
  438.  
  439.     for(i = 0 ; i < NumBaudRates ; i++)
  440.     {
  441.         Diff = Rate - BaudRates[i];
  442.  
  443.         if(Diff >= 0 && Diff < Min)
  444.         {
  445.             Min    = Diff;
  446.             Index    = i;
  447.         }
  448.     }
  449.  
  450.     if(BaudRates[Index] != Config -> SerialConfig -> BaudRate)
  451.     {
  452.         Config -> SerialConfig -> BaudRate = BaudRates[Index];
  453.  
  454.         ConfigChanged = TRUE;
  455.  
  456.         UpdateRequired = TRUE;
  457.     }
  458.  
  459.     return(NULL);
  460. }
  461.  
  462. STRPTR
  463. RexxBeepScreen(struct RexxPkt *Pkt)
  464. {
  465.     BellSignal();
  466.  
  467.     return(NULL);
  468. }
  469.  
  470. STRPTR
  471. RexxCallMenu(struct RexxPkt *Pkt)
  472. {
  473.     enum    {    ARG_CALLMENU_TITLE };
  474.  
  475.     STRPTR Buffer;
  476.  
  477.     if(Buffer = CreateMatchBuffer(Args[ARG_CALLMENU_TITLE]))
  478.     {
  479.         WORD i;
  480.  
  481.         Results[0] = RC_WARN;
  482.  
  483.             /* Scan the menu list... */
  484.  
  485.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  486.         {
  487.                 /* Did we get a valid name string? */
  488.  
  489.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  490.             {
  491.                     /* Does the name match our template? */
  492.  
  493.                 if(MatchBuffer(Buffer,TermMenu[i] . nm_Label))
  494.                 {
  495.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  496.  
  497.                     Results[0] = RC_OK;
  498.  
  499.                     break;
  500.                 }
  501.             }
  502.         }
  503.  
  504.         DeleteMatchBuffer(Buffer);
  505.     }
  506.     else
  507.     {
  508.         Results[0] = RC_ERROR;
  509.         Results[1] = ERROR_NO_FREE_STORE;
  510.     }
  511.  
  512.     return(NULL);
  513. }
  514.  
  515. STRPTR
  516. RexxCapture(struct RexxPkt *Pkt)
  517. {
  518.     enum    {    ARG_CAPTURE_TO,ARG_CAPTURE_NAME };
  519.  
  520.     if(!Stricmp(Args[ARG_CAPTURE_TO],"PRINTER"))
  521.     {
  522.         if(!PrinterCapture)
  523.             OpenPrinterCapture(FALSE);
  524.     }
  525.     else
  526.     {
  527.         if(!Stricmp(Args[ARG_CAPTURE_TO],"FILE"))
  528.         {
  529.             if(FileCapture)
  530.             {
  531.                 Results[0] = RC_ERROR;
  532.                 Results[1] = ERROR_OBJECT_IN_USE;
  533.             }
  534.             else
  535.             {
  536.                 if(Args[ARG_CAPTURE_NAME])
  537.                 {
  538.                     if(FileCapture = BufferOpen(Args[ARG_CAPTURE_NAME],"a"))
  539.                         strcpy(CaptureName,Args[ARG_CAPTURE_NAME]);
  540.                     else
  541.                     {
  542.                         Results[0] = RC_ERROR;
  543.                         Results[1] = IoErr();
  544.                     }
  545.                 }
  546.                 else
  547.                 {
  548.                     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  549.                                 *DummyChar;
  550.                     struct FileRequester    *FileRequest;
  551.  
  552.                     if(!CaptureName[0])
  553.                     {
  554.                         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  555.  
  556.                         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  557.                             CaptureName[0] = 0;
  558.                     }
  559.  
  560.                     strcpy(DummyBuffer,CaptureName);
  561.  
  562.                     DummyChar = PathPart(DummyBuffer);
  563.  
  564.                     *DummyChar = 0;
  565.  
  566.                     BlockWindows();
  567.  
  568.                     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  569.                     {
  570.                         BYTE Continue;
  571.  
  572.                         if(GetFileSize(DummyBuffer))
  573.                         {
  574.                             Continue = TRUE;
  575.  
  576.                             switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  577.                             {
  578.                                 case 1:
  579.  
  580.                                     FileCapture = BufferOpen(DummyBuffer,"w");
  581.                                     break;
  582.  
  583.                                 case 2:
  584.  
  585.                                     FileCapture = BufferOpen(DummyBuffer,"a");
  586.                                     break;
  587.  
  588.                                 case 0:
  589.  
  590.                                     Results[0] = RC_WARN;
  591.                                     Continue = FALSE;
  592.                                     break;
  593.                             }
  594.                         }
  595.                         else
  596.                         {
  597.                             Continue = TRUE;
  598.  
  599.                             FileCapture = BufferOpen(DummyBuffer,"w");
  600.                         }
  601.  
  602.                         if(Continue)
  603.                         {
  604.                             if(!FileCapture)
  605.                             {
  606.                                 MyEasyRequest(Window,LocaleString(MSG_GLOBAL_ERROR_OPENING_FILE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),DummyBuffer);
  607.  
  608.                                 Results[0] = RC_ERROR;
  609.                                 Results[1] = IoErr();
  610.                             }
  611.                             else
  612.                             {
  613.                                 strcpy(CaptureName,DummyBuffer);
  614.  
  615.                                 CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  616.                             }
  617.                         }
  618.  
  619.                         FreeAslRequest(FileRequest);
  620.                     }
  621.  
  622.                     ReleaseWindows();
  623.                 }
  624.             }
  625.         }
  626.         else
  627.         {
  628.             Results[0] = RC_ERROR;
  629.             Results[1] = ERROR_REQUIRED_ARG_MISSING;
  630.         }
  631.     }
  632.  
  633.     ConOutputUpdate();
  634.  
  635.     Forbid();
  636.  
  637.     CheckItem(MEN_CAPTURE_TO_FILE,        FileCapture != NULL);
  638.     CheckItem(MEN_CAPTURE_TO_PRINTER,    PrinterCapture != NULL);
  639.  
  640.     Permit();
  641.  
  642.     return(NULL);
  643. }
  644.  
  645. STRPTR
  646. RexxClear(struct RexxPkt *Pkt)
  647. {
  648.     enum    {    ARG_CLEAR_FROM,ARG_CLEAR_FORCE };
  649.  
  650.     if(!Stricmp(Args[ARG_CLEAR_FROM],"BUFFER"))
  651.     {
  652.         if(Lines)
  653.         {
  654.             if(Args[ARG_CLEAR_FORCE])
  655.             {
  656.                 FreeBuffer();
  657.  
  658.                 TerminateBuffer();
  659.             }
  660.             else
  661.             {
  662.                 BlockWindows();
  663.  
  664.                 if(MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_BUFFER_STILL_HOLDS_LINES_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),Lines))
  665.                 {
  666.                     FreeBuffer();
  667.  
  668.                     TerminateBuffer();
  669.                 }
  670.                 else
  671.                     Results[0] = RC_WARN;
  672.  
  673.                 ReleaseWindows();
  674.             }
  675.         }
  676.     }
  677.     else
  678.     {
  679.         WORD ListIndex;
  680.  
  681.         if((ListIndex = ToList(Args[ARG_CLEAR_FROM])) != -1)
  682.             ClearGenericList(GenericListTable[ListIndex]);
  683.         else
  684.         {
  685.             Results[0] = RC_ERROR;
  686.             Results[1] = TERMERROR_UNKNOWN_LIST;
  687.         }
  688.     }
  689.  
  690.     return(NULL);
  691. }
  692.  
  693. STRPTR
  694. RexxClearScreen(struct RexxPkt *Pkt)
  695. {
  696.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  697.         XEmulatorClearConsole(XEM_IO);
  698.     else
  699.     {
  700.         DropMarker();
  701.  
  702.         ConBypass("\033[2J\033[H",-1);
  703.     }
  704.  
  705.     return(NULL);
  706. }
  707.  
  708. STRPTR
  709. RexxClose(struct RexxPkt *Pkt)
  710. {
  711.     enum    {    ARG_CLOSE_FROM };
  712.  
  713.     STATIC STRPTR ValidArgs[3] =
  714.     {
  715.         "PRINTER",
  716.         "FILE",
  717.         "ALL"
  718.     };
  719.  
  720.     WORD i;
  721.  
  722.     for(i = 0 ; i < 3 ; i++)
  723.     {
  724.         if(!Stricmp(Args[ARG_CLOSE_FROM],ValidArgs[i]))
  725.         {
  726.             if(i == 0 || i == 2)
  727.             {
  728.                 if(PrinterCapture)
  729.                     ClosePrinterCapture(TRUE);
  730.             }
  731.  
  732.             if(i == 1 || i == 2)
  733.             {
  734.                 if(FileCapture)
  735.                 {
  736.                     BufferClose(FileCapture);
  737.  
  738.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  739.  
  740.                     FileCapture = NULL;
  741.  
  742.                     if(!GetFileSize(CaptureName))
  743.                         DeleteFile(CaptureName);
  744.                     else
  745.                     {
  746.                         AddProtection(CaptureName,FIBF_EXECUTE);
  747.  
  748.                         if(Config -> MiscConfig -> CreateIcons)
  749.                             AddIcon(CaptureName,FILETYPE_TEXT,TRUE);
  750.                     }
  751.  
  752.                     ConOutputUpdate();
  753.                 }
  754.             }
  755.  
  756.             return(NULL);
  757.         }
  758.     }
  759.  
  760.     Results[0] = RC_ERROR;
  761.     Results[1] = ERROR_TOO_MANY_ARGS;
  762.  
  763.     return(NULL);
  764. }
  765.  
  766. STRPTR
  767. RexxCloseDevice(struct RexxPkt *Pkt)
  768. {
  769.     ClearSerial();
  770.  
  771.     DeleteSerial();
  772.  
  773.     return(NULL);
  774. }
  775.  
  776. STRPTR
  777. RexxCloseRequester(struct RexxPkt *Pkt)
  778. {
  779.     if(ThisProcess)
  780.         Signal(ThisProcess,SIG_BREAK);
  781.     else
  782.         Results[0] = RC_WARN;
  783.  
  784.     return(NULL);
  785. }
  786.  
  787. STRPTR
  788. RexxDeactivate(struct RexxPkt *Pkt)
  789. {
  790.     Forbid();
  791.  
  792.     if(Window)
  793.         DoIconify = TRUE;
  794.  
  795.     Permit();
  796.  
  797.     return(NULL);
  798. }
  799.  
  800. STRPTR
  801. RexxDial(struct RexxPkt *Pkt)
  802. {
  803.     enum    {    ARG_SYNC,ARG_DIAL_NUM };
  804.  
  805.     struct PhoneNode    *DialNode;
  806.     struct GenericList    *List;
  807.  
  808.     if(Args[ARG_DIAL_NUM])
  809.     {
  810.         struct List *LocalList;
  811.  
  812.         if(LocalList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  813.         {
  814.             LONG Len = strlen(Args[ARG_DIAL_NUM]);
  815.  
  816.             NewList(LocalList);
  817.  
  818.             if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len + 1,MEMF_ANY | MEMF_CLEAR))
  819.             {
  820.                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  821.  
  822.                 strcpy(DialNode -> VanillaNode . ln_Name,Args[ARG_DIAL_NUM]);
  823.  
  824.                 AddTail(LocalList,&DialNode -> VanillaNode);
  825.  
  826.                 FreeDialList(TRUE);
  827.  
  828.                 DialList = LocalList;
  829.             }
  830.             else
  831.             {
  832.                 FreeVecPooled(LocalList);
  833.  
  834.                 Results[0] = RC_ERROR;
  835.                 Results[1] = ERROR_NO_FREE_STORE;
  836.  
  837.                 return(NULL);
  838.             }
  839.         }
  840.     }
  841.     else
  842.     {
  843.         if(GenericListCount(List = GenericListTable[GLIST_DIAL]))
  844.         {
  845.             struct DialNode *Node = (struct DialNode *)FirstGenericListNode(List);
  846.  
  847.             if(Node)
  848.             {
  849.                 LONG Len;
  850.  
  851.                 if(!DialList)
  852.                 {
  853.                     if(DialList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY | MEMF_CLEAR))
  854.                         NewList(DialList);
  855.                 }
  856.  
  857.                 if(DialList)
  858.                 {
  859.                     while(Node)
  860.                     {
  861.                         if(Node -> Entry)
  862.                             Len = 0;
  863.                         else
  864.                             Len = strlen(Node -> Node . ln_Name) + 1;
  865.  
  866.                         if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len,MEMF_ANY | MEMF_CLEAR))
  867.                         {
  868.                             if(Node -> Entry)
  869.                                 DialNode -> Entry = Node -> Entry;
  870.                             else
  871.                             {
  872.                                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  873.  
  874.                                 strcpy(DialNode -> VanillaNode . ln_Name,Node -> Node . ln_Name);
  875.                             }
  876.  
  877.                             AddTail(DialList,&DialNode -> VanillaNode);
  878.                         }
  879.                         else
  880.                         {
  881.                             FreeDialList(FALSE);
  882.  
  883.                             Results[0] = RC_ERROR;
  884.                             Results[1] = ERROR_NO_FREE_STORE;
  885.  
  886.                             return(NULL);
  887.                         }
  888.  
  889.                         Node = (struct DialNode *)NextGenericListNode(List);
  890.                     }
  891.                 }
  892.             }
  893.         }
  894.     }
  895.  
  896.     if(DialList)
  897.     {
  898.         if(DialList -> lh_Head -> ln_Succ)
  899.         {
  900.             DoDial = DIAL_LIST;
  901.  
  902.             Forbid();
  903.  
  904.             if(!DialMsg && Args[ARG_SYNC])
  905.             {
  906.                 DialMsg = Pkt -> RexxMsg;
  907.  
  908.                 Pkt -> RexxMsg = NULL;
  909.             }
  910.  
  911.             Permit();
  912.         }
  913.         else
  914.         {
  915.             FreeDialList(FALSE);
  916.  
  917.             Results[0] = RC_ERROR;
  918.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  919.         }
  920.     }
  921.     else
  922.     {
  923.         Results[0] = RC_ERROR;
  924.         Results[1] = ERROR_NO_FREE_STORE;
  925.     }
  926.  
  927.     return(NULL);
  928. }
  929.  
  930. STRPTR
  931. RexxDelay(struct RexxPkt *Pkt)
  932. {
  933.     enum    {    ARG_DELAY_MICROSECONDS,ARG_DELAY_SECONDS,ARG_DELAY_MINUTES,ARG_DELAY_QUIET };
  934.  
  935.     LONG    Seconds = 0,
  936.         Micros;
  937.     ULONG    Signals;
  938.     BYTE    Quiet;
  939.  
  940.     if(Args[ARG_DELAY_QUIET] || !ReadRequest || !WriteRequest)
  941.         Quiet = TRUE;
  942.     else
  943.         Quiet = FALSE;
  944.  
  945.     if(Args[ARG_DELAY_MINUTES])
  946.         Seconds += 60 * (*(LONG *)Args[ARG_DELAY_MINUTES]);
  947.  
  948.     if(Args[ARG_DELAY_SECONDS])
  949.         Seconds += *(LONG *)Args[ARG_DELAY_SECONDS];
  950.  
  951.     if(Args[ARG_DELAY_MICROSECONDS])
  952.         Micros = *(LONG *)Args[ARG_DELAY_MICROSECONDS];
  953.     else
  954.         Micros = 0;
  955.  
  956.     if(Seconds || Micros)
  957.     {
  958.         StartTime(Seconds,Micros);
  959.  
  960.         BlockWindows();
  961.  
  962.         if(Marking)
  963.             DropMarker();
  964.  
  965.         if(Quiet)
  966.             Signals = NULL;
  967.         else
  968.         {
  969.             if(DataHold)
  970.             {
  971.                 ConProcess(DataHold,DataSize);
  972.  
  973.                 Status = STATUS_READY;
  974.  
  975.                 DataHold = NULL;
  976.  
  977.                 RestartSerial(TRUE);
  978.             }
  979.  
  980.             Signals = CheckSignal(SIG_SERIAL);
  981.         }
  982.  
  983.         FOREVER
  984.         {
  985.             if(Signals & SIG_SERIAL)
  986.             {
  987.                 if(!WaitSerialRead())
  988.                 {
  989.                     LONG Length;
  990.  
  991.                     BytesIn++;
  992.  
  993.                     if(Translate_CR_LF)
  994.                         Length = (* Translate_CR_LF)(ReadBuffer,1);
  995.                     else
  996.                         Length = 1;
  997.  
  998.                     if(Length)
  999.                     {
  1000.                         ConProcess(ReadBuffer,Length);
  1001.  
  1002.                         Status = STATUS_READY;
  1003.                     }
  1004.  
  1005.                         /* Check how many bytes are still in
  1006.                          * the serial buffer.
  1007.                          */
  1008.  
  1009.                     if(Length = GetSerialWaiting())
  1010.                     {
  1011.                         if(Length > SerialBufferSize)
  1012.                             Length = SerialBufferSize;
  1013.  
  1014.                         if(Length > Config -> SerialConfig -> Quantum)
  1015.                             Length = Config -> SerialConfig -> Quantum;
  1016.  
  1017.                         if(!DoSerialRead(ReadBuffer,Length))
  1018.                         {
  1019.                             BytesIn += Length;
  1020.  
  1021.                             if(Translate_CR_LF)
  1022.                                 Length = (* Translate_CR_LF)(ReadBuffer,Length);
  1023.  
  1024.                                 /* Send the data to the console. */
  1025.  
  1026.                             if(Length)
  1027.                                 ConProcess(ReadBuffer,Length);
  1028.  
  1029.                             Status = STATUS_READY;
  1030.                         }
  1031.                     }
  1032.                 }
  1033.  
  1034.                 RestartSerial(TRUE);
  1035.             }
  1036.  
  1037.             if(Signals & SIG_BREAK)
  1038.             {
  1039.                 StopTime();
  1040.  
  1041.                 Results[0] = RC_WARN;
  1042.  
  1043.                 break;
  1044.             }
  1045.  
  1046.             if(Signals & SIG_TIMER)
  1047.             {
  1048.                 WaitIO(TimeRequest);
  1049.  
  1050.                 break;
  1051.             }
  1052.  
  1053.             if(Quiet)
  1054.                 Signals = Wait(SIG_TIMER | SIG_BREAK);
  1055.             else
  1056.                 Signals = Wait(SIG_TIMER | SIG_BREAK | SIG_SERIAL);
  1057.         }
  1058.  
  1059.         ReleaseWindows();
  1060.     }
  1061.  
  1062.     return(NULL);
  1063. }
  1064.  
  1065. STRPTR
  1066. RexxDuplex(struct RexxPkt *Pkt)
  1067. {
  1068.     enum    {    ARG_DUPLEX_FULL,ARG_DUPLEX_HALF };
  1069.  
  1070.     BYTE Mode;
  1071.  
  1072.     if(Args[ARG_DUPLEX_FULL])
  1073.         Mode = DUPLEX_FULL;
  1074.  
  1075.     if(Args[ARG_DUPLEX_HALF])
  1076.         Mode = DUPLEX_HALF;
  1077.  
  1078.     if(Config -> SerialConfig -> Duplex != Mode)
  1079.     {
  1080.         Config -> SerialConfig -> Duplex = Mode;
  1081.  
  1082.         UpdateRequired = TRUE;
  1083.  
  1084.         ConfigChanged = TRUE;
  1085.     }
  1086.  
  1087.     return(NULL);
  1088. }
  1089.  
  1090. STRPTR
  1091. RexxFault(struct RexxPkt *Pkt)
  1092. {
  1093.     enum    {    ARG_FAULT_CODE };
  1094.  
  1095.     LONG    Code = *(LONG *)Args[ARG_FAULT_CODE];
  1096.     UBYTE    RexxResultString[256];
  1097.     STRPTR    Result;
  1098.  
  1099.     if(Code >= ERR10_001 && Code <= ERR10_048)
  1100.         Result = LocaleString(MSG_AREXX_SYSERR10_001_TXT + Code - ERR10_001);
  1101.     else
  1102.     {
  1103.         if(Code >= TERMERROR_NO_DATA_TO_PROCESS && Code <= TERMERROR_WRONG_LIST)
  1104.             Result = LocaleString(MSG_AREXX_HOSTERR_000_TXT + Code - TERMERROR_NO_DATA_TO_PROCESS);
  1105.         else
  1106.         {
  1107.             Fault(Code,"",RexxResultString,256);
  1108.  
  1109.             Result = &RexxResultString[2];
  1110.         }
  1111.     }
  1112.  
  1113.     return(CreateResult(Result,Results));
  1114. }
  1115.  
  1116. STRPTR
  1117. RexxGetClip(struct RexxPkt *Pkt)
  1118. {
  1119.     enum    {    ARG_GETCLIP_UNIT };
  1120.  
  1121.     struct IFFHandle    *Handle;
  1122.     STRPTR             ResultBuffer = NULL;
  1123.  
  1124.     if(Handle = AllocIFF())
  1125.     {
  1126.         if(Args[ARG_GETCLIP_UNIT])
  1127.             Handle -> iff_Stream = (ULONG)OpenClipboard(*(LONG *)Args[ARG_GETCLIP_UNIT]);
  1128.         else
  1129.             Handle -> iff_Stream = (ULONG)OpenClipboard(Config -> ClipConfig -> ClipboardUnit);
  1130.  
  1131.         if(Handle -> iff_Stream)
  1132.         {
  1133.             InitIFFasClip(Handle);
  1134.  
  1135.             if(!OpenIFF(Handle,IFFF_READ))
  1136.             {
  1137.                 if(!StopChunk(Handle,ID_FTXT,ID_CHRS))
  1138.                 {
  1139.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  1140.                     {
  1141.                         struct ContextNode *ContextNode;
  1142.  
  1143.                         ContextNode = CurrentChunk(Handle);
  1144.  
  1145.                         if(ContextNode -> cn_Type == ID_FTXT && ContextNode -> cn_Size > 0)
  1146.                         {
  1147.                             STRPTR Result;
  1148.  
  1149.                             if(Result = (STRPTR)AllocVecPooled(ContextNode -> cn_Size,MEMF_ANY))
  1150.                             {
  1151.                                 if(ReadChunkBytes(Handle,Result,ContextNode -> cn_Size) == ContextNode -> cn_Size)
  1152.                                     ResultBuffer = CreateArgstring(Result,ContextNode -> cn_Size);
  1153.  
  1154.                                 FreeVecPooled(Result);
  1155.                             }
  1156.                             else
  1157.                             {
  1158.                                 Results[0] = RC_ERROR;
  1159.                                 Results[1] = ERROR_NO_FREE_STORE;
  1160.                             }
  1161.                         }
  1162.                         else
  1163.                             Results[0] = RC_WARN;
  1164.                     }
  1165.                     else
  1166.                     {
  1167.                         Results[0] = RC_ERROR;
  1168.                         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1169.                     }
  1170.                 }
  1171.                 else
  1172.                 {
  1173.                     Results[0] = RC_ERROR;
  1174.                     Results[1] = ERROR_OBJECT_NOT_FOUND;
  1175.                 }
  1176.  
  1177.                 CloseIFF(Handle);
  1178.             }
  1179.             else
  1180.             {
  1181.                 Results[0] = RC_ERROR;
  1182.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1183.             }
  1184.  
  1185.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  1186.         }
  1187.         else
  1188.         {
  1189.             Results[0] = RC_ERROR;
  1190.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  1191.         }
  1192.  
  1193.         FreeIFF(Handle);
  1194.     }
  1195.     else
  1196.     {
  1197.         Results[0] = RC_ERROR;
  1198.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1199.     }
  1200.  
  1201.     return(ResultBuffer);
  1202. }
  1203.  
  1204. STRPTR
  1205. RexxGoOnline(struct RexxPkt *Pkt)
  1206. {
  1207.     ObtainSemaphore(&OnlineSemaphore);
  1208.  
  1209.     if(!Online)
  1210.     {
  1211.         WasOnline        = Online;
  1212.         Online            = TRUE;
  1213.  
  1214.         ReleaseSemaphore(&OnlineSemaphore);
  1215.  
  1216.         BaudCount        = 0;
  1217.         BaudBuffer[0]        = 0;
  1218.         BaudPending        = FALSE;
  1219.         CurrentPay        = 0;
  1220.  
  1221.         ObtainSemaphore(&PatternSemaphore);
  1222.  
  1223.         ChosenEntry        = NULL;
  1224.         ChosenPattern        = NULL;
  1225.  
  1226.         ReleaseSemaphore(&PatternSemaphore);
  1227.  
  1228.         Password[0]        = 0;
  1229.         UserName[0]        = 0;
  1230.         SendStartup        = FALSE;
  1231.         LimitCount        = -1;
  1232.         CurrentBBSName[0]    = 0;
  1233.         CurrentBBSComment[0]    = 0;
  1234.         CurrentBBSNumber[0]    = 0;
  1235.  
  1236.         Forbid();
  1237.  
  1238.         SetDialMenu(FALSE);
  1239.  
  1240.         Permit();
  1241.     }
  1242.     else
  1243.         ReleaseSemaphore(&OnlineSemaphore);
  1244.  
  1245.     return(NULL);
  1246. }
  1247.  
  1248. STRPTR
  1249. RexxHangup(struct RexxPkt *Pkt)
  1250. {
  1251.     if(!WriteRequest)
  1252.     {
  1253.         Results[0] = RC_WARN;
  1254.  
  1255.         return(NULL);
  1256.     }
  1257.  
  1258.     BlockWindows();
  1259.  
  1260.     HangUp();
  1261.  
  1262.         /* We are no longer online. */
  1263.  
  1264.     ObtainSemaphore(&OnlineSemaphore);
  1265.  
  1266.     if(Online)
  1267.     {
  1268.         WasOnline    = Online;
  1269.         Online        = FALSE;
  1270.     }
  1271.  
  1272.     ReleaseSemaphore(&OnlineSemaphore);
  1273.  
  1274.         /* Reset time limit. */
  1275.  
  1276.     LimitCount = -1;
  1277.  
  1278.         /* Clear the password. */
  1279.  
  1280.     Password[0]        = 0;
  1281.     UserName[0]        = 0;
  1282.  
  1283.     CurrentBBSName[0]    = 0;
  1284.     CurrentBBSComment[0]    = 0;
  1285.     CurrentBBSNumber[0]    = 0;
  1286.  
  1287.         /* Note the  last action. */
  1288.  
  1289.     LogAction(LocaleString(MSG_TERMMAIN_LOGMSG_HANG_UP_TXT));
  1290.  
  1291.     ReleaseWindows();
  1292.  
  1293.         /* Execute logoff macro. */
  1294.  
  1295.     if(WasOnline && Config -> CommandConfig -> LogoffMacro[0])
  1296.         SerialCommand(Config -> CommandConfig -> LogoffMacro);
  1297.  
  1298.         /* Update the logfile. */
  1299.  
  1300.     StopCall(FALSE);
  1301.  
  1302.         /* Don't execute the logoff macro twice. */
  1303.  
  1304.     ObtainSemaphore(&OnlineSemaphore);
  1305.  
  1306.     WasOnline = FALSE;
  1307.  
  1308.     ReleaseSemaphore(&OnlineSemaphore);
  1309.  
  1310.         /* Enable the dialing functions. */
  1311.  
  1312.     SetDialMenu(TRUE);
  1313.  
  1314.     if(Config -> ModemConfig -> RedialAfterHangup)
  1315.     {
  1316.         if(DialList)
  1317.         {
  1318.             if(DialList -> lh_Head -> ln_Succ)
  1319.                 DoDial = DIAL_REDIAL;
  1320.         }
  1321.     }
  1322.  
  1323.     ObtainSemaphore(&PatternSemaphore);
  1324.  
  1325.     ChosenEntry    = NULL;
  1326.     ChosenPattern    = NULL;
  1327.  
  1328.     ReleaseSemaphore(&PatternSemaphore);
  1329.  
  1330.     return(NULL);
  1331. }
  1332.  
  1333. STRPTR
  1334. RexxHelp(struct RexxPkt *Pkt)
  1335. {
  1336.     enum    {    ARG_HELP_COMMAND,ARG_HELP_PROMPT };
  1337.  
  1338.     if(Args[ARG_HELP_PROMPT])
  1339.         GuideSetup();
  1340.     else
  1341.     {
  1342.         WORD i;
  1343.  
  1344.         for(i = 0 ; i < CommandTableSize ; i++)
  1345.         {
  1346.             if(!Stricmp(Args[ARG_HELP_COMMAND],CommandTable[i] . Name))
  1347.             {
  1348.                 if(CommandTable[i] . Arguments)
  1349.                     return(CreateResult(CommandTable[i] . Arguments,Results));
  1350.                 else
  1351.                     return(CreateResult(",",Results));
  1352.             }
  1353.         }
  1354.  
  1355.         Results[0] = RC_ERROR;
  1356.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1357.     }
  1358.  
  1359.     return(NULL);
  1360. }
  1361.  
  1362. STRPTR
  1363. RexxOpen(struct RexxPkt *Pkt)
  1364. {
  1365.     enum    {    ARG_OPEN_NAME,ARG_OPEN_TO };
  1366.  
  1367.     WORD Index = ToConfig(Args[ARG_OPEN_TO]);
  1368.  
  1369.     if(Index == -1 || Index > DATATYPE_PHONEBOOK)
  1370.     {
  1371.         Results[0] = RC_ERROR;
  1372.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1373.     }
  1374.     else
  1375.     {
  1376.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1377.         STRPTR    FileName;
  1378.  
  1379.         if(Args[ARG_OPEN_NAME])
  1380.             FileName = Args[ARG_OPEN_NAME];
  1381.         else
  1382.         {
  1383.             STRPTR             Title;
  1384.             struct FileRequester    *FileRequest;
  1385.  
  1386.             FileName = NULL;
  1387.  
  1388.             switch(Index)
  1389.             {
  1390.                 case DATATYPE_TRANSLATIONS:
  1391.  
  1392.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_TRANSLATION_TXT);
  1393.                     break;
  1394.  
  1395.                 case DATATYPE_FUNCTIONKEYS:
  1396.  
  1397.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_KEYBOARD_MACROS_TXT);
  1398.                     break;
  1399.  
  1400.                 case DATATYPE_CURSORKEYS:
  1401.  
  1402.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_CURSOR_KEYS_TXT);
  1403.                     break;
  1404.  
  1405.                 case DATATYPE_FASTMACROS:
  1406.  
  1407.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_FAST_MACROS_TXT);
  1408.                     break;
  1409.  
  1410.                 case DATATYPE_HOTKEYS:
  1411.  
  1412.                     Title = LocaleString(MSG_HOTKEYPANEL_LOAD_HOTKEYS_TXT);
  1413.                     break;
  1414.  
  1415.                 case DATATYPE_SPEECH:
  1416.  
  1417.                     Title = LocaleString(MSG_SPEECHPANEL_LOAD_SPEECH_SETTINGS_TXT);
  1418.                     break;
  1419.  
  1420.                 case DATATYPE_SOUND:
  1421.  
  1422.                     Title = LocaleString(MSG_SOUNDPANEL_LOAD_SOUNDS_TXT);
  1423.                     break;
  1424.  
  1425.                 case DATATYPE_BUFFER:
  1426.  
  1427.                     Title = LocaleString(MSG_TERMMAIN_LOAD_BUFFER_TXT);
  1428.                     break;
  1429.  
  1430.                 case DATATYPE_CONFIGURATION:
  1431.  
  1432.                     Title = LocaleString(MSG_TERMMAIN_OPEN_PREFERENCES_TXT);
  1433.                     break;
  1434.  
  1435.                 case DATATYPE_PHONEBOOK:
  1436.  
  1437.                     Title = LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT);
  1438.                     break;
  1439.             }
  1440.  
  1441.             BlockWindows();
  1442.  
  1443.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,FALSE,FALSE,FALSE,"Ok",TRUE))
  1444.             {
  1445.                 FileName = DummyBuffer;
  1446.  
  1447.                 FreeAslRequest(FileRequest);
  1448.             }
  1449.             else
  1450.                 Results[0] = RC_WARN;
  1451.  
  1452.             ReleaseWindows();
  1453.         }
  1454.  
  1455.         if(FileName)
  1456.         {
  1457.             if(!GetFileSize(FileName))
  1458.             {
  1459.                 Results[0] = RC_ERROR;
  1460.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1461.  
  1462.                 return(NULL);
  1463.             }
  1464.  
  1465.             BlockWindows();
  1466.  
  1467.             switch(Index)
  1468.             {
  1469.                 case DATATYPE_TRANSLATIONS:
  1470.                 {
  1471.                     struct TranslationEntry    **Send,
  1472.                                 **Receive = NULL;
  1473.                     BYTE            Success = FALSE;
  1474.  
  1475.                     if(Send = AllocTranslationTable())
  1476.                     {
  1477.                         if(Receive = AllocTranslationTable())
  1478.                         {
  1479.                             if(!(Success = LoadTranslationTables(FileName,Send,Receive)))
  1480.                             {
  1481.                                 Results[0] = RC_ERROR;
  1482.                                 Results[1] = IoErr();
  1483.                             }
  1484.                         }
  1485.                         else
  1486.                         {
  1487.                             Results[0] = RC_ERROR;
  1488.                             Results[1] = ERROR_NO_FREE_STORE;
  1489.                         }
  1490.                     }
  1491.                     else
  1492.                     {
  1493.                         Results[0] = RC_ERROR;
  1494.                         Results[1] = ERROR_NO_FREE_STORE;
  1495.                     }
  1496.  
  1497.                     if(!Success)
  1498.                     {
  1499.                         if(Send)
  1500.                             FreeTranslationTable(Send);
  1501.  
  1502.                         if(Receive)
  1503.                             FreeTranslationTable(Receive);
  1504.                     }
  1505.                     else
  1506.                     {
  1507.                         strcpy(Config -> FileConfig -> TranslationFileName,FileName);
  1508.  
  1509.                         strcpy(LastTranslation,FileName);
  1510.  
  1511.                         FreeTranslationTable(SendTable);
  1512.                         FreeTranslationTable(ReceiveTable);
  1513.  
  1514.                         SendTable    = Send;
  1515.                         ReceiveTable    = Receive;
  1516.                     }
  1517.                 }
  1518.  
  1519.                 break;
  1520.  
  1521.                 case DATATYPE_FUNCTIONKEYS:
  1522.                 {
  1523.                     if(!LoadMacros(FileName,MacroKeys))
  1524.                     {
  1525.                         Results[0] = RC_ERROR;
  1526.                         Results[1] = IoErr();
  1527.                     }
  1528.                     else
  1529.                     {
  1530.                         MacroChanged = FALSE;
  1531.  
  1532.                         strcpy(Config -> FileConfig -> MacroFileName,FileName);
  1533.  
  1534.                         strcpy(LastMacros,FileName);
  1535.                     }
  1536.                 }
  1537.  
  1538.                 break;
  1539.  
  1540.                 case DATATYPE_CURSORKEYS:
  1541.                 {
  1542.                     if(!ReadIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  1543.                     {
  1544.                         Results[0] = RC_ERROR;
  1545.                         Results[1] = IoErr();
  1546.                     }
  1547.                     else
  1548.                     {
  1549.                         CursorKeysChanged = FALSE;
  1550.  
  1551.                         strcpy(Config -> FileConfig -> CursorFileName,FileName);
  1552.  
  1553.                         strcpy(LastCursorKeys,FileName);
  1554.                     }
  1555.                 }
  1556.  
  1557.                 break;
  1558.  
  1559.                 case DATATYPE_FASTMACROS:
  1560.                 {
  1561.                     if(!LoadFastMacros(FileName,&FastMacroList))
  1562.                     {
  1563.                         Results[0] = RC_ERROR;
  1564.                         Results[1] = IoErr();
  1565.                     }
  1566.                     else
  1567.                     {
  1568.                         strcpy(Config -> FileConfig -> FastMacroFileName,FileName);
  1569.  
  1570.                         strcpy(LastFastMacros,FileName);
  1571.  
  1572.                         FastMacrosChanged = FALSE;
  1573.                     }
  1574.  
  1575.                     RefreshFastWindow(TRUE);
  1576.                 }
  1577.  
  1578.                 break;
  1579.  
  1580.                 case DATATYPE_HOTKEYS:
  1581.                 {
  1582.                     if(!LoadHotkeys(FileName,&Hotkeys))
  1583.                     {
  1584.                         Results[0] = RC_ERROR;
  1585.                         Results[1] = IoErr();
  1586.                     }
  1587.                     else
  1588.                     {
  1589.                         strcpy(LastKeys,FileName);
  1590.  
  1591.                         HotkeysChanged = FALSE;
  1592.  
  1593.                         SetupCx();
  1594.                     }
  1595.                 }
  1596.  
  1597.                 break;
  1598.  
  1599.                 case DATATYPE_SPEECH:
  1600.                 {
  1601.                     if(!ReadIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  1602.                     {
  1603.                         Results[0] = RC_ERROR;
  1604.                         Results[1] = IoErr();
  1605.                     }
  1606.                     else
  1607.                     {
  1608.                         strcpy(LastSpeech,FileName);
  1609.  
  1610.                         SpeechSetup();
  1611.  
  1612.                         SpeechChanged = FALSE;
  1613.                     }
  1614.                 }
  1615.  
  1616.                 break;
  1617.  
  1618.                 case DATATYPE_SOUND:
  1619.                 {
  1620.                     if(!ReadIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  1621.                     {
  1622.                         Results[0] = RC_ERROR;
  1623.                         Results[1] = IoErr();
  1624.                     }
  1625.                     else
  1626.                     {
  1627.                         strcpy(LastSound,FileName);
  1628.  
  1629.                         SoundInit();
  1630.  
  1631.                         SoundChanged = FALSE;
  1632.                     }
  1633.                 }
  1634.  
  1635.                 break;
  1636.  
  1637.                 case DATATYPE_BUFFER:
  1638.                 {
  1639.                     BPTR SomeFile;
  1640.  
  1641.                     if(SomeFile = Open(FileName,MODE_OLDFILE))
  1642.                     {
  1643.                         LONG Len;
  1644.  
  1645.                         LineRead(NULL,NULL,NULL);
  1646.  
  1647.                         while((Len = LineRead(SomeFile,FileName,80)) > 0)
  1648.                             CaptureParser(FileName,Len,AddLine);
  1649.  
  1650.                         Close(SomeFile);
  1651.  
  1652.                         BufferChanged = TRUE;
  1653.                     }
  1654.                     else
  1655.                     {
  1656.                         Results[0] = RC_ERROR;
  1657.                         Results[1] = IoErr();
  1658.                     }
  1659.                 }
  1660.  
  1661.                 break;
  1662.  
  1663.                 case DATATYPE_CONFIGURATION:
  1664.                 {
  1665.                     if(ReadConfig(FileName,PrivateConfig))
  1666.                     {
  1667.                         SwapConfig(PrivateConfig,Config);
  1668.  
  1669.                         strcpy(LastConfig,FileName);
  1670.  
  1671.                         ConfigSetup();
  1672.  
  1673.                         ConfigChanged = FALSE;
  1674.                     }
  1675.                     else
  1676.                     {
  1677.                         Results[0] = RC_ERROR;
  1678.                         Results[1] = IoErr();
  1679.                     }
  1680.                 }
  1681.  
  1682.                 break;
  1683.  
  1684.                 case DATATYPE_PHONEBOOK:
  1685.                 {
  1686.                     if(ChosenEntry)
  1687.                     {
  1688.                         Results[0] = RC_ERROR;
  1689.                         Results[1] = ERROR_OBJECT_IN_USE;
  1690.                     }
  1691.                     else
  1692.                     {
  1693.                         if(!LoadPhonebook(FileName))
  1694.                         {
  1695.                             Results[0] = RC_ERROR;
  1696.                             Results[1] = IoErr();
  1697.                         }
  1698.                         else
  1699.                         {
  1700.                             strcpy(LastPhone,FileName);
  1701.  
  1702.                             PhonebookChanged = FALSE;
  1703.  
  1704.                             RebuildMenu = TRUE;
  1705.                         }
  1706.                     }
  1707.                 }
  1708.  
  1709.                 break;
  1710.             }
  1711.  
  1712.             ReleaseWindows();
  1713.         }
  1714.         else
  1715.             Results[0] = RC_WARN;
  1716.     }
  1717.  
  1718.     return(NULL);
  1719. }
  1720.  
  1721. STRPTR
  1722. RexxOpenDevice(struct RexxPkt *Pkt)
  1723. {
  1724.     enum    {    ARG_OPENDEVICE_NAME,ARG_OPENDEVICE_UNIT };
  1725.  
  1726.     if(ReadRequest)
  1727.     {
  1728.         Results[0] = RC_ERROR;
  1729.         Results[1] = TERMERROR_DEVICE_DRIVER_STILL_OPEN;
  1730.     }
  1731.     else
  1732.     {
  1733.         if(Args[ARG_OPENDEVICE_NAME])
  1734.         {
  1735.             strcpy(Config -> SerialConfig -> SerialDevice,Args[ARG_OPENDEVICE_NAME]);
  1736.  
  1737.             ConfigChanged = TRUE;
  1738.         }
  1739.  
  1740.         if(Args[ARG_OPENDEVICE_UNIT])
  1741.         {
  1742.             Config -> SerialConfig -> UnitNumber = *(LONG *)Args[ARG_OPENDEVICE_UNIT];
  1743.  
  1744.             ConfigChanged = TRUE;
  1745.         }
  1746.  
  1747.         BlockWindows();
  1748.  
  1749.         ReopenSerial();
  1750.  
  1751.         ReleaseWindows();
  1752.     }
  1753.  
  1754.     return(NULL);
  1755. }
  1756.  
  1757. STRPTR
  1758. RexxOpenRequester(struct RexxPkt *Pkt)
  1759. {
  1760.     enum    {    ARG_OPENREQUESTER_REQUESTER };
  1761.  
  1762.     WORD Index;
  1763.  
  1764.     if((Index = ToRequester(Args[ARG_OPENREQUESTER_REQUESTER])) == -1)
  1765.     {
  1766.         Results[0] = RC_ERROR;
  1767.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1768.     }
  1769.     else
  1770.     {
  1771.         ULONG    Code;
  1772.         WORD    i;
  1773.  
  1774.         switch(Index)
  1775.         {
  1776.             case REQUESTER_SERIAL:
  1777.  
  1778.                 Code = MEN_SERIAL;
  1779.                 break;
  1780.  
  1781.             case REQUESTER_MODEM:
  1782.  
  1783.                 Code = MEN_MODEM;
  1784.                 break;
  1785.  
  1786.             case REQUESTER_SCREEN:
  1787.  
  1788.                 Code = MEN_SCREEN;
  1789.                 break;
  1790.  
  1791.             case REQUESTER_TERMINAL:
  1792.  
  1793.                 Code = MEN_TERMINAL;
  1794.                 break;
  1795.  
  1796.             case REQUESTER_EMULATION:
  1797.  
  1798.                 Code = MEN_SET_EMULATION;
  1799.                 break;
  1800.  
  1801.             case REQUESTER_CLIPBOARD:
  1802.  
  1803.                 Code = MEN_CLIPBOARD;
  1804.                 break;
  1805.  
  1806.             case REQUESTER_CAPTURE:
  1807.  
  1808.                 Code = MEN_CAPTURE;
  1809.                 break;
  1810.  
  1811.             case REQUESTER_COMMANDS:
  1812.  
  1813.                 Code = MEN_COMMANDS;
  1814.                 break;
  1815.  
  1816.             case REQUESTER_MISC:
  1817.  
  1818.                 Code = MEN_MISC;
  1819.                 break;
  1820.  
  1821.             case REQUESTER_PATH:
  1822.  
  1823.                 Code = MEN_PATH;
  1824.                 break;
  1825.  
  1826.             case REQUESTER_TRANSFER:
  1827.  
  1828.                 Code = MEN_TRANSFER;
  1829.                 break;
  1830.  
  1831.             case REQUESTER_TRANSLATIONS:
  1832.  
  1833.                 Code = MEN_TRANSLATION;
  1834.                 break;
  1835.  
  1836.             case REQUESTER_FUNCTIONKEYS:
  1837.  
  1838.                 Code = MEN_MACROS;
  1839.                 break;
  1840.  
  1841.             case REQUESTER_CURSORKEYS:
  1842.  
  1843.                 Code = MEN_CURSORKEYS;
  1844.                 break;
  1845.  
  1846.             case REQUESTER_FASTMACROS:
  1847.  
  1848.                 Code = MEN_FAST_MACROS;
  1849.                 break;
  1850.  
  1851.             case REQUESTER_HOTKEYS:
  1852.  
  1853.                 Code = MEN_HOTKEYS;
  1854.                 break;
  1855.  
  1856.             case REQUESTER_SPEECH:
  1857.  
  1858.                 Code = MEN_SPEECH;
  1859.                 break;
  1860.  
  1861.             case REQUESTER_SOUND:
  1862.  
  1863.                 Code = MEN_SOUND;
  1864.                 break;
  1865.  
  1866.  
  1867.             case REQUESTER_PHONE:
  1868.  
  1869.                 Code = MEN_PHONEBOOK;
  1870.                 break;
  1871.         }
  1872.  
  1873.             /* Scan the menu list... */
  1874.  
  1875.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  1876.         {
  1877.                 /* Did we get a valid name string? */
  1878.  
  1879.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  1880.             {
  1881.                 if((ULONG)TermMenu[i] . nm_UserData == Code)
  1882.                 {
  1883.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  1884.  
  1885.                     break;
  1886.                 }
  1887.             }
  1888.         }
  1889.     }
  1890.  
  1891.     return(NULL);
  1892. }
  1893.  
  1894. STRPTR
  1895. RexxParity(struct RexxPkt *Pkt)
  1896. {
  1897.     enum    {    ARG_PARITY_EVEN,ARG_PARITY_ODD,ARG_PARITY_NONE,ARG_PARITY_MARK,ARG_PARITY_SPACE };
  1898.  
  1899.     BYTE Mode;
  1900.  
  1901.     if(Args[ARG_PARITY_EVEN])
  1902.         Mode = PARITY_EVEN;
  1903.  
  1904.     if(Args[ARG_PARITY_ODD])
  1905.         Mode = PARITY_ODD;
  1906.  
  1907.     if(Args[ARG_PARITY_NONE])
  1908.         Mode = PARITY_NONE;
  1909.  
  1910.     if(Args[ARG_PARITY_MARK])
  1911.         Mode = PARITY_MARK;
  1912.  
  1913.     if(Args[ARG_PARITY_SPACE])
  1914.         Mode = PARITY_SPACE;
  1915.  
  1916.     if(Config -> SerialConfig -> Parity != Mode)
  1917.     {
  1918.         Config -> SerialConfig -> Parity = Mode;
  1919.  
  1920.         UpdateRequired = TRUE;
  1921.  
  1922.         ConfigChanged = TRUE;
  1923.     }
  1924.  
  1925.     return(NULL);
  1926. }
  1927.  
  1928. STRPTR
  1929. RexxPasteClip(struct RexxPkt *Pkt)
  1930. {
  1931.     enum    {    ARG_PASTECLIP_UNIT };
  1932.  
  1933.     struct DataMsg    *Msg;
  1934.     LONG         Unit;
  1935.  
  1936.     if(Args[ARG_PASTECLIP_UNIT])
  1937.         Unit = *(LONG *)Args[ARG_PASTECLIP_UNIT];
  1938.     else
  1939.         Unit = Config -> ClipConfig -> ClipboardUnit;
  1940.  
  1941.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  1942.     {
  1943.         Msg -> Type = DATAMSGTYPE_WRITECLIP;
  1944.         Msg -> Size = Unit;
  1945.  
  1946.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  1947.     }
  1948.     else
  1949.     {
  1950.         Results[0] = RC_ERROR;
  1951.         Results[1] = ERROR_NO_FREE_STORE;
  1952.     }
  1953.  
  1954.     return(NULL);
  1955. }
  1956.  
  1957. STRPTR
  1958. RexxPrint(struct RexxPkt *Pkt)
  1959. {
  1960.     enum    {    ARG_PRINT_FROM,ARG_PRINT_TO,ARG_PRINT_SERIAL,ARG_PRINT_MODEM,ARG_PRINT_SCREEN,
  1961.             ARG_PRINT_TERMINAL,ARG_PRINT_USER,ARG_PRINT_COMMENT,ARG_PRINT_SIZE,
  1962.             ARG_PRINT_DATE,ARG_PRINT_BITS };
  1963.  
  1964.     WORD    Index,Mode = -1;
  1965.     ULONG    Flags = NULL;
  1966.  
  1967.     if(Args[ARG_PRINT_SERIAL])
  1968.         Flags |= PRINT_SERIAL;
  1969.  
  1970.     if(Args[ARG_PRINT_MODEM])
  1971.         Flags |= PRINT_MODEM;
  1972.  
  1973.     if(Args[ARG_PRINT_SCREEN])
  1974.         Flags |= PRINT_SCREEN;
  1975.  
  1976.     if(Args[ARG_PRINT_TERMINAL])
  1977.         Flags |= PRINT_TERMINAL;
  1978.  
  1979.     if(Args[ARG_PRINT_USER])
  1980.         Flags |= PRINT_USERNAME;
  1981.  
  1982.     if(Args[ARG_PRINT_COMMENT])
  1983.         Flags |= PRINT_COMMENT;
  1984.  
  1985.     if(Args[ARG_PRINT_SIZE])
  1986.         Flags |= PRINT_SIZE;
  1987.  
  1988.     if(Args[ARG_PRINT_DATE])
  1989.         Flags |= PRINT_DATE;
  1990.  
  1991.     if(Args[ARG_PRINT_BITS])
  1992.         Flags |= PRINT_BITS;
  1993.  
  1994.     if((Index = ToList(Args[ARG_PRINT_FROM])) == -1)
  1995.     {
  1996.         if(!Stricmp(Args[ARG_PRINT_FROM],"SCREENTEXT"))
  1997.         {
  1998.             if(!RasterEnabled)
  1999.             {
  2000.                 Results[0] = RC_ERROR;
  2001.                 Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  2002.  
  2003.                 return(NULL);
  2004.             }
  2005.             else
  2006.                 Mode = 0;
  2007.         }
  2008.  
  2009.         if(!Stricmp(Args[ARG_PRINT_FROM],"CLIPBOARD"))
  2010.             Mode = 1;
  2011.  
  2012.         if(!Stricmp(Args[ARG_PRINT_FROM],"BUFFER"))
  2013.             Mode = 2;
  2014.     }
  2015.  
  2016.     if(Index == -1 && Mode == -1)
  2017.     {
  2018.         Results[0] = RC_ERROR;
  2019.         Results[1] = TERMERROR_UNKNOWN_LIST;
  2020.     }
  2021.     else
  2022.     {
  2023.         BYTE    Continue = TRUE;
  2024.         LONG    Error = 0;
  2025.         BPTR    File;
  2026.         STRPTR    Name;
  2027.  
  2028.         if(Args[ARG_PRINT_TO])
  2029.             Name = Args[ARG_PRINT_TO];
  2030.         else
  2031.             Name = "PRT:";
  2032.  
  2033.         if(File = Open(Name,MODE_NEWFILE))
  2034.         {
  2035.             struct Window        *ReqWindow;
  2036.             struct EasyStruct     Easy;
  2037.  
  2038.             Easy . es_StructSize    = sizeof(struct EasyStruct);
  2039.             Easy . es_Flags        = NULL;
  2040.             Easy . es_Title        = (UBYTE *)LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  2041.             Easy . es_GadgetFormat    = (UBYTE *)LocaleString(MSG_PRINT_STOP_TXT);
  2042.             Easy . es_TextFormat    = (UBYTE *)LocaleString(MSG_GLOBAL_PRINTING_TXT);
  2043.  
  2044.             BlockWindows();
  2045.  
  2046.             if(ReqWindow = BuildEasyRequest(Window,&Easy,NULL))
  2047.             {
  2048.                 switch(Index)
  2049.                 {
  2050.                     case GLIST_DIAL:
  2051.                     {
  2052.                         struct GenericList *List = GenericListTable[Index];
  2053.  
  2054.                         ObtainSemaphore(&List -> ListSemaphore);
  2055.  
  2056.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2057.                         {
  2058.                             struct DialNode *TempNode;
  2059.  
  2060.                             for(TempNode = (struct DialNode *)List -> ListHeader . mlh_Head ; Continue && TempNode -> Node . ln_Succ ; TempNode = (struct DialNode *)TempNode -> Node . ln_Succ)
  2061.                             {
  2062.                                 if(TempNode -> Entry)
  2063.                                     Continue = PrintEntry(File,ReqWindow,TRUE,&Error,TempNode -> Entry,Flags);
  2064.                                 else
  2065.                                     Continue = PrintText(File,ReqWindow,&Error,"\n\"???\" (%s)",TempNode -> Node . ln_Name);
  2066.                             }
  2067.                         }
  2068.  
  2069.                         ReleaseSemaphore(&List -> ListSemaphore);
  2070.                     }
  2071.  
  2072.                     break;
  2073.  
  2074.                     case GLIST_UPLOAD:
  2075.                     case GLIST_DOWNLOAD:
  2076.                     {
  2077.                         struct GenericList *List = GenericListTable[Index];
  2078.  
  2079.                         ObtainSemaphore(&List -> ListSemaphore);
  2080.  
  2081.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2082.                         {
  2083.                             struct Node *TempNode;
  2084.  
  2085.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2086.                                 Continue = PrintFileInformation(File,ReqWindow,&Error,TempNode -> ln_Name,Flags);
  2087.                         }
  2088.  
  2089.                         ReleaseSemaphore(&List -> ListSemaphore);
  2090.                     }
  2091.  
  2092.                     break;
  2093.  
  2094.                     case GLIST_WAIT:
  2095.                     {
  2096.                         struct GenericList *List = GenericListTable[Index];
  2097.  
  2098.                         ObtainSemaphore(&List -> ListSemaphore);
  2099.  
  2100.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2101.                         {
  2102.                             struct Node *TempNode;
  2103.  
  2104.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2105.                                 Continue = PrintText(File,ReqWindow,&Error,"%s\n",TempNode -> ln_Name);
  2106.                         }
  2107.  
  2108.                         ReleaseSemaphore(&List -> ListSemaphore);
  2109.                     }
  2110.  
  2111.                     break;
  2112.  
  2113.                     default:
  2114.                     {
  2115.                         switch(Mode)
  2116.                         {
  2117.                             case 0:
  2118.  
  2119.                                 Continue = PrintScreen(File,ReqWindow,&Error);
  2120.                                 break;
  2121.  
  2122.                             case 1:
  2123.  
  2124.                                 Continue = PrintClip(File,ReqWindow,&Error);
  2125.                                 break;
  2126.  
  2127.                             case 2:
  2128.  
  2129.                                 Continue = PrintBuffer(File,ReqWindow,&Error);
  2130.                                 break;
  2131.                         }
  2132.  
  2133.                         break;
  2134.                     }
  2135.  
  2136.                     break;
  2137.                 }
  2138.  
  2139.                 FreeSysRequest(ReqWindow);
  2140.             }
  2141.  
  2142.             ReleaseWindows();
  2143.  
  2144.             Close(File);
  2145.         }
  2146.         else
  2147.             Error = IoErr();
  2148.  
  2149.         if(Error)
  2150.         {
  2151.             Results[0] = RC_ERROR;
  2152.             Results[1] = Error;
  2153.         }
  2154.         else
  2155.         {
  2156.             if(!Continue)
  2157.                 Results[0] = RC_WARN;
  2158.         }
  2159.     }
  2160.  
  2161.     return(NULL);
  2162. }
  2163.  
  2164. STRPTR
  2165. RexxProcessIO(struct RexxPkt *Pkt)
  2166. {
  2167.     enum    {    ARG_PROCESSIO_ON,ARG_PROCESSIO_OFF };
  2168.  
  2169.     Forbid();
  2170.  
  2171.     if(Args[ARG_PROCESSIO_ON])
  2172.         ProcessIO = TRUE;
  2173.  
  2174.     if(Args[ARG_PROCESSIO_OFF])
  2175.         ProcessIO = FALSE;
  2176.  
  2177.     Permit();
  2178.  
  2179.     return(NULL);
  2180. }
  2181.  
  2182. STRPTR
  2183. RexxProtocol(struct RexxPkt *Pkt)
  2184. {
  2185.     enum    {    ARG_PROTOCOL_NONE,ARG_PROTOCOL_RTSCTS,ARG_PROTOCOL_RTSCTSDTR };
  2186.  
  2187.     BYTE Mode;
  2188.  
  2189.     if(Args[ARG_PROTOCOL_NONE])
  2190.         Mode = HANDSHAKING_NONE;
  2191.  
  2192.     if(Args[ARG_PROTOCOL_RTSCTS])
  2193.         Mode = HANDSHAKING_RTSCTS;
  2194.  
  2195.     if(Args[ARG_PROTOCOL_RTSCTSDTR])
  2196.         Mode = HANDSHAKING_RTSCTS_DSR;
  2197.  
  2198.     if(Config -> SerialConfig -> HandshakingProtocol != Mode)
  2199.     {
  2200.         Config -> SerialConfig -> HandshakingProtocol = Mode;
  2201.  
  2202.         UpdateRequired = TRUE;
  2203.  
  2204.         ConfigChanged = TRUE;
  2205.     }
  2206.  
  2207.     return(NULL);
  2208. }
  2209.  
  2210. STRPTR
  2211. RexxPutClip(struct RexxPkt *Pkt)
  2212. {
  2213.     enum    {    ARG_PUTCLIP_UNIT,ARG_PUTCLIP_TEXT };
  2214.  
  2215.     struct IFFHandle    *Handle;
  2216.     LONG             Unit;
  2217.     BYTE             Success = FALSE;
  2218.  
  2219.     if(Args[ARG_PUTCLIP_UNIT])
  2220.         Unit = *(LONG *)Args[ARG_PUTCLIP_UNIT];
  2221.     else
  2222.         Unit = Config -> ClipConfig -> ClipboardUnit;
  2223.  
  2224.     if(Handle = AllocIFF())
  2225.     {
  2226.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(Unit))
  2227.         {
  2228.             InitIFFasClip(Handle);
  2229.  
  2230.             if(!OpenIFF(Handle,IFFF_WRITE))
  2231.             {
  2232.                 if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  2233.                 {
  2234.                     if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  2235.                     {
  2236.                         LONG Len = strlen(Args[ARG_PUTCLIP_TEXT]);
  2237.  
  2238.                         if(WriteChunkBytes(Handle,Args[ARG_PUTCLIP_TEXT],Len) == Len)
  2239.                         {
  2240.                             if(!PopChunk(Handle))
  2241.                                 Success = TRUE;
  2242.                         }
  2243.                     }
  2244.                 }
  2245.  
  2246.                 if(PopChunk(Handle))
  2247.                     Success = FALSE;
  2248.  
  2249.                 CloseIFF(Handle);
  2250.             }
  2251.             else
  2252.             {
  2253.                 Results[0] = RC_ERROR;
  2254.                 Results[1] = ERROR_NO_FREE_STORE;
  2255.             }
  2256.  
  2257.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  2258.         }
  2259.         else
  2260.         {
  2261.             Results[0] = RC_ERROR;
  2262.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  2263.         }
  2264.  
  2265.         FreeIFF(Handle);
  2266.     }
  2267.     else
  2268.     {
  2269.         Results[0] = RC_ERROR;
  2270.         Results[1] = ERROR_NO_FREE_STORE;
  2271.     }
  2272.  
  2273.     if(!Success && !Results[0])
  2274.     {
  2275.         Results[0] = RC_ERROR;
  2276.         Results[1] = TERMERROR_CLIPBOARD_ERROR;
  2277.     }
  2278.  
  2279.     return(NULL);
  2280. }
  2281.  
  2282. STRPTR
  2283. RexxQuit(struct RexxPkt *Pkt)
  2284. {
  2285.     enum    {    ARG_QUIT_FORCE };
  2286.  
  2287.     struct DataMsg *Msg;
  2288.  
  2289.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  2290.     {
  2291.         Pkt -> RexxMsg -> rm_Result1 = RC_WARN;
  2292.         Pkt -> RexxMsg -> rm_Result2 = 0;
  2293.  
  2294.         ReplyMsg(Pkt -> RexxMsg);
  2295.  
  2296.         Pkt -> RexxMsg = NULL;
  2297.  
  2298.         Msg -> Type = DATAMSGTYPE_MENU;
  2299.         Msg -> Size = MEN_QUIT;
  2300.  
  2301.         if(Args[ARG_QUIT_FORCE])
  2302.             Msg -> Data = (APTR)(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT);
  2303.         else
  2304.             Msg -> Data = NULL;
  2305.  
  2306.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  2307.     }
  2308.     else
  2309.     {
  2310.         Results[0] = RC_ERROR;
  2311.         Results[1] = ERROR_NO_FREE_STORE;
  2312.     }
  2313.  
  2314.     return(NULL);
  2315. }
  2316.  
  2317. STATIC STRPTR    RexxReadBuffer;
  2318. STATIC LONG    RexxReadIndex,
  2319.         RexxReadLen;
  2320. STATIC BYTE    RexxReadDone,
  2321.         RexxReadEcho;
  2322.  
  2323. STATIC BOOLEAN
  2324. RexxReadBypassVerbatim(STRPTR Buffer,LONG Size)
  2325. {
  2326.     while(Size-- > 0)
  2327.     {
  2328.         switch(*Buffer)
  2329.         {
  2330.             case '\n':
  2331.  
  2332.                 break;
  2333.  
  2334.             case '\r':
  2335.  
  2336.                 RexxReadDone = TRUE;
  2337.                 break;
  2338.  
  2339.             case '\b':
  2340.             case '\30':
  2341.  
  2342.                 while(RexxReadIndex > 0)
  2343.                 {
  2344.                     if(RexxReadEcho)
  2345.                         SerWriteVerbatim("\b",1,FALSE);
  2346.  
  2347.                     RexxReadIndex--;
  2348.                 }
  2349.  
  2350.                 break;
  2351.  
  2352.             default:
  2353.  
  2354.                 if(RexxReadIndex < RexxReadLen && ((*Buffer >= ' ' && *Buffer < 127) || *Buffer >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2355.                 {
  2356.                     RexxReadBuffer[RexxReadIndex++] = *Buffer;
  2357.  
  2358.                     if(RexxReadEcho)
  2359.                         SerWriteVerbatim(Buffer,1,FALSE);
  2360.                 }
  2361.  
  2362.                 break;
  2363.         }
  2364.  
  2365.         Buffer++;
  2366.     }
  2367.  
  2368.     return(FALSE);
  2369. }
  2370.  
  2371. STATIC BOOLEAN
  2372. RexxReadBypassTranslate(STRPTR Buffer,LONG Size)
  2373. {
  2374.     struct TranslationHandle    Handle;
  2375.     UBYTE                Temp;
  2376.  
  2377.     while(Size-- > 0)
  2378.     {
  2379.         TranslateSetup(&Handle,Buffer,1,&Temp,1,ReceiveTable);
  2380.  
  2381.         while(!RexxReadDone && TranslateBuffer(&Handle))
  2382.         {
  2383.             switch(Temp)
  2384.             {
  2385.                 case '\n':
  2386.  
  2387.                     break;
  2388.  
  2389.                 case '\r':
  2390.  
  2391.                     RexxReadDone = TRUE;
  2392.  
  2393.                     break;
  2394.  
  2395.                 case '\b':
  2396.                 case '\30':
  2397.  
  2398.                     while(RexxReadIndex > 0)
  2399.                     {
  2400.                         if(RexxReadEcho)
  2401.                             SerWriteVerbatim("\b",1,FALSE);
  2402.  
  2403.                         RexxReadIndex--;
  2404.                     }
  2405.  
  2406.                     break;
  2407.  
  2408.                 default:
  2409.  
  2410.                     if(RexxReadIndex < RexxReadLen && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2411.                     {
  2412.                         RexxReadBuffer[RexxReadIndex++] = Temp;
  2413.  
  2414.                         if(RexxReadEcho)
  2415.                             SerWriteVerbatim(&Temp,1,FALSE);
  2416.                     }
  2417.  
  2418.                     break;
  2419.             }
  2420.         }
  2421.  
  2422.         Buffer++;
  2423.     }
  2424.  
  2425.     return(FALSE);
  2426. }
  2427.  
  2428. STRPTR
  2429. RexxRead(struct RexxPkt *Pkt)
  2430. {
  2431.     enum    {    ARG_READ_NUM,ARG_READ_CR,ARG_READ_NOECHO,ARG_READ_VERBATIM,ARG_READ_PROMPT };
  2432.  
  2433.     LONG Len,BytesRead = 0;
  2434.  
  2435.     if(!ReadRequest || !WriteRequest)
  2436.     {
  2437.         Results[0] = RC_WARN;
  2438.  
  2439.         return(NULL);
  2440.     }
  2441.  
  2442.     if(Args[ARG_READ_NUM])
  2443.     {
  2444.         Len = *(LONG *)Args[ARG_READ_NUM] + 1;
  2445.  
  2446.         if(Len < 1)
  2447.         {
  2448.             Results[0] = RC_ERROR;
  2449.             Results[1] = ERROR_BAD_NUMBER;
  2450.  
  2451.             return(NULL);
  2452.         }
  2453.  
  2454.         if(Len > MAX_RESULT_LEN + 1)
  2455.             Len = MAX_RESULT_LEN + 1;
  2456.     }
  2457.     else
  2458.         Len = MAX_RESULT_LEN + 1;
  2459.  
  2460.     if(Args[ARG_READ_PROMPT])
  2461.         SerialCommand(Args[ARG_READ_PROMPT]);
  2462.  
  2463.     if(Marking)
  2464.         DropMarker();
  2465.  
  2466.     BlockWindows();
  2467.  
  2468.     if(Args[ARG_READ_CR])
  2469.     {
  2470.         Forbid();
  2471.  
  2472.         LT_UnlockWindow(Window);
  2473.  
  2474.         Window -> Flags |= WFLG_RMBTRAP;
  2475.  
  2476.         Permit();
  2477.  
  2478.         NormalCursor();
  2479.     }
  2480.  
  2481.     Status = STATUS_READY;
  2482.  
  2483.     if(Args[ARG_READ_VERBATIM] || !ReceiveTable)
  2484.     {
  2485.         if(Args[ARG_READ_CR])
  2486.         {
  2487.             ULONG     Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2488.             UBYTE    *Char;
  2489.             BYTE     Echo,Done = FALSE;
  2490.             LONG     Index = 0;
  2491.             STRPTR     Buffer;
  2492.  
  2493.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2494.             {
  2495.                 if(Args[ARG_READ_NOECHO])
  2496.                     Echo = FALSE;
  2497.                 else
  2498.                     Echo = TRUE;
  2499.  
  2500.                 RexxReadEcho = Echo;
  2501.  
  2502.                 if(RexxTimeoutVal)
  2503.                     StartTime(RexxTimeoutVal,0);
  2504.  
  2505.                 if(DataHold)
  2506.                 {
  2507.                     while(DataSize-- > 0)
  2508.                     {
  2509.                         Char = DataHold++;
  2510.  
  2511.                         switch(*Char)
  2512.                         {
  2513.                             case '\n':
  2514.  
  2515.                                 break;
  2516.  
  2517.                             case '\r':
  2518.  
  2519.                                 Done = TRUE;
  2520.  
  2521.                                 if(Echo)
  2522.                                     SerWrite(ReadBuffer,1);
  2523.  
  2524.                                 break;
  2525.  
  2526.                             case '\b':
  2527.  
  2528.                                 if(Index > 0)
  2529.                                 {
  2530.                                     Index--;
  2531.  
  2532.                                     if(Echo)
  2533.                                         SerWrite(ReadBuffer,1);
  2534.                                 }
  2535.  
  2536.                                 break;
  2537.  
  2538.                             case '\30':
  2539.  
  2540.                                 if(Echo)
  2541.                                 {
  2542.                                     while(Index > 0)
  2543.                                     {
  2544.                                         Index--;
  2545.  
  2546.                                         SerWrite("\b",1);
  2547.                                     }
  2548.                                 }
  2549.                                 else
  2550.                                     Index = 0;
  2551.  
  2552.                                 break;
  2553.  
  2554.                             default:
  2555.  
  2556.                                 if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2557.                                 {
  2558.                                     Buffer[Index++] = *Char;
  2559.  
  2560.                                     if(Echo)
  2561.                                         SerWrite(ReadBuffer,1);
  2562.                                 }
  2563.  
  2564.                                 break;
  2565.                         }
  2566.                     }
  2567.  
  2568.                     DataHold = NULL;
  2569.  
  2570.                     RestartSerial(TRUE);
  2571.                 }
  2572.  
  2573.                 if(CheckSerialRead())
  2574.                     Signals = SIG_SERIAL;
  2575.                 else
  2576.                     Signals = NULL;
  2577.  
  2578.                 do
  2579.                 {
  2580.                     if(Signals & SIG_WINDOW)
  2581.                     {
  2582.                         SerWriteBypass = RexxReadBypassVerbatim;
  2583.  
  2584.                         RexxReadBuffer    = Buffer;
  2585.                         RexxReadIndex    = Index;
  2586.                         RexxReadLen    = Len;
  2587.                         RexxReadDone    = Done;
  2588.  
  2589.                         while(HandleWindow());
  2590.  
  2591.                         Buffer    = RexxReadBuffer;
  2592.                         Index    = RexxReadIndex;
  2593.                         Len    = RexxReadLen;
  2594.                         Done    = RexxReadDone;
  2595.  
  2596.                         SerWriteBypass = NULL;
  2597.                     }
  2598.  
  2599.                     if(Signals & SIG_SERIAL)
  2600.                     {
  2601.                         if(!WaitSerialRead())
  2602.                         {
  2603.                             LONG Length;
  2604.  
  2605.                             BytesIn++;
  2606.  
  2607.                             if(Translate_CR_LF)
  2608.                                 Length = (* Translate_CR_LF)(ReadBuffer,1);
  2609.                             else
  2610.                                 Length = 1;
  2611.  
  2612.                             Char = ReadBuffer;
  2613.  
  2614.                             while(Length--)
  2615.                             {
  2616.                                 switch(*Char)
  2617.                                 {
  2618.                                     case '\n':
  2619.  
  2620.                                         break;
  2621.  
  2622.                                     case '\r':
  2623.  
  2624.                                         Done = TRUE;
  2625.  
  2626.                                         if(Echo)
  2627.                                             SerWrite(ReadBuffer,1);
  2628.  
  2629.                                         break;
  2630.  
  2631.                                     case '\b':
  2632.  
  2633.                                         if(Index > 0)
  2634.                                         {
  2635.                                             Index--;
  2636.  
  2637.                                             if(Echo)
  2638.                                                 SerWrite(ReadBuffer,1);
  2639.                                         }
  2640.  
  2641.                                         break;
  2642.  
  2643.                                     case '\30':
  2644.  
  2645.                                         if(Echo)
  2646.                                         {
  2647.                                             while(Index > 0)
  2648.                                             {
  2649.                                                 Index--;
  2650.  
  2651.                                                 SerWrite("\b",1);
  2652.                                             }
  2653.                                         }
  2654.                                         else
  2655.                                             Index = 0;
  2656.  
  2657.                                     default:
  2658.  
  2659.                                         if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2660.                                         {
  2661.                                             Buffer[Index++] = *Char;
  2662.  
  2663.                                             if(Echo)
  2664.                                                 SerWrite(ReadBuffer,1);
  2665.                                         }
  2666.  
  2667.                                         break;
  2668.                                 }
  2669.  
  2670.                                 Char++;
  2671.                             }
  2672.                         }
  2673.  
  2674.                         RestartSerial(TRUE);
  2675.                     }
  2676.  
  2677.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  2678.                     {
  2679.                         Results[0] = RC_WARN;
  2680.  
  2681.                         break;
  2682.                     }
  2683.  
  2684.                     if(!Done)
  2685.                         Signals = Wait(SignalMask | SIG_WINDOW);
  2686.                 }
  2687.                 while(!Done);
  2688.  
  2689.                 if(RexxTimeoutVal)
  2690.                     StopTime();
  2691.  
  2692.                 if(Index)
  2693.                 {
  2694.                     STRPTR Result;
  2695.  
  2696.                     Buffer[Index] = 0;
  2697.  
  2698.                     Result = CreateResult(Buffer,Results);
  2699.  
  2700.                     if(Args[ARG_READ_CR])
  2701.                     {
  2702.                         Forbid();
  2703.  
  2704.                         Window -> Flags &= ~WFLG_RMBTRAP;
  2705.  
  2706.                         LT_LockWindow(Window);
  2707.  
  2708.                         Permit();
  2709.                     }
  2710.  
  2711.                     ReleaseWindows();
  2712.  
  2713.                     FreeVecPooled(Buffer);
  2714.  
  2715.                     return(Result);
  2716.                 }
  2717.                 else
  2718.                     Results[0] = RC_WARN;
  2719.  
  2720.                 FreeVecPooled(Buffer);
  2721.             }
  2722.             else
  2723.             {
  2724.                 Results[0] = RC_ERROR;
  2725.                 Results[1] = ERROR_NO_FREE_STORE;
  2726.             }
  2727.         }
  2728.         else
  2729.         {
  2730.             STRPTR Buffer;
  2731.  
  2732.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2733.             {
  2734.                 STRPTR Result;
  2735.  
  2736.                 if(DataHold && DataSize >= Len - 1)
  2737.                 {
  2738.                     CopyMem(DataHold,Buffer,Len - 1);
  2739.  
  2740.                     BytesRead = Len - 1;
  2741.  
  2742.                     if(DataSize == Len - 1)
  2743.                     {
  2744.                         DataHold = NULL;
  2745.  
  2746.                         RestartSerial(TRUE);
  2747.                     }
  2748.                     else
  2749.                     {
  2750.                         DataHold += Len - 1;
  2751.                         DataSize -= Len - 1;
  2752.                     }
  2753.                 }
  2754.                 else
  2755.                 {
  2756.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2757.  
  2758.                     ClearSerial();
  2759.  
  2760.                     ClrSignal(SignalMask);
  2761.  
  2762.                     if(RexxTimeoutVal)
  2763.                         StartTime(RexxTimeoutVal,0);
  2764.  
  2765.                     if(DataHold)
  2766.                     {
  2767.                         CopyMem(DataHold,Buffer,DataSize);
  2768.  
  2769.                         StartSerialRead(Buffer + DataSize,Len - 1 - DataSize);
  2770.  
  2771.                         BytesRead = DataSize;
  2772.  
  2773.                         DataHold = NULL;
  2774.                     }
  2775.                     else
  2776.                         StartSerialRead(Buffer,Len - 1);
  2777.  
  2778.                     FOREVER
  2779.                     {
  2780.                         Signals = Wait(SignalMask);
  2781.  
  2782.                         if(Signals & SIG_SERIAL)
  2783.                         {
  2784.                             if(RexxTimeoutVal)
  2785.                                 StopTime();
  2786.  
  2787.                                 /* Did the request terminate gracefully? */
  2788.  
  2789.                             if(!WaitSerialRead())
  2790.                             {
  2791.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2792.  
  2793.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2794.                             }
  2795.                             else
  2796.                                 Results[0] = RC_ERROR;
  2797.  
  2798.                             break;
  2799.                         }
  2800.  
  2801.                         if(Signals & SIG_BREAK)
  2802.                         {
  2803.                             StopSerialRead();
  2804.  
  2805.                             if(RexxTimeoutVal)
  2806.                                 StopTime();
  2807.  
  2808.                             Results[0] = RC_WARN;
  2809.  
  2810.                             break;
  2811.                         }
  2812.  
  2813.                         if(Signals & SIG_TIMER)
  2814.                         {
  2815.                             StopSerialRead();
  2816.  
  2817.                             WaitIO(TimeRequest);
  2818.  
  2819.                             if(ReadRequest -> IOSer . io_Actual)
  2820.                             {
  2821.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2822.  
  2823.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2824.                             }
  2825.                             else
  2826.                             {
  2827.                                 ULONG Waiting = GetSerialWaiting();
  2828.  
  2829.                                 if(Waiting)
  2830.                                 {
  2831.                                         /* Don't read more than actually wanted. */
  2832.  
  2833.                                     if(!DoSerialRead(Buffer,MIN(Len - 1,Waiting)))
  2834.                                     {
  2835.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  2836.  
  2837.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  2838.                                     }
  2839.                                 }
  2840.                             }
  2841.  
  2842.                             break;
  2843.                         }
  2844.                     }
  2845.                 }
  2846.  
  2847.                 if(BytesRead)
  2848.                     Result = CreateResultLen(Buffer,Results,BytesRead);
  2849.                 else
  2850.                 {
  2851.                     Results[0] = RC_WARN;
  2852.  
  2853.                     Result = NULL;
  2854.                 }
  2855.  
  2856.                 FreeVecPooled(Buffer);
  2857.  
  2858.                 RestartSerial(TRUE);
  2859.  
  2860.                 if(Args[ARG_READ_CR])
  2861.                 {
  2862.                     Forbid();
  2863.  
  2864.                     Window -> Flags &= ~WFLG_RMBTRAP;
  2865.  
  2866.                     LT_LockWindow(Window);
  2867.  
  2868.                     Permit();
  2869.                 }
  2870.  
  2871.                 ReleaseWindows();
  2872.  
  2873.                 return(Result);
  2874.             }
  2875.             else
  2876.             {
  2877.                 Results[0] = RC_ERROR;
  2878.                 Results[1] = ERROR_NO_FREE_STORE;
  2879.             }
  2880.  
  2881.             RestartSerial(TRUE);
  2882.         }
  2883.     }
  2884.     else
  2885.     {
  2886.         if(Args[ARG_READ_CR])
  2887.         {
  2888.             ULONG                 Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2889.             UBYTE                *Char,Temp;
  2890.             BYTE                 Echo,Done = FALSE;
  2891.             LONG                 Index = 0;
  2892.             struct TranslationHandle     Handle;
  2893.             STRPTR                 Buffer;
  2894.  
  2895.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2896.             {
  2897.                 if(Args[ARG_READ_NOECHO])
  2898.                     Echo = FALSE;
  2899.                 else
  2900.                     Echo = TRUE;
  2901.  
  2902.                 RexxReadEcho = Echo;
  2903.  
  2904.                 if(RexxTimeoutVal)
  2905.                     StartTime(RexxTimeoutVal,0);
  2906.  
  2907.                 if(DataHold)
  2908.                 {
  2909.                     while(DataSize-- > 0)
  2910.                     {
  2911.                         Char = DataHold++;
  2912.  
  2913.                         TranslateSetup(&Handle,Char,1,&Temp,1,ReceiveTable);
  2914.  
  2915.                         while(!Done && TranslateBuffer(&Handle))
  2916.                         {
  2917.                             switch(Temp)
  2918.                             {
  2919.                                 case '\n':
  2920.  
  2921.                                     break;
  2922.  
  2923.                                 case '\r':
  2924.  
  2925.                                     Done = TRUE;
  2926.  
  2927.                                     if(Echo)
  2928.                                         SerWrite(&Temp,1);
  2929.  
  2930.                                     break;
  2931.  
  2932.                                 case '\b':
  2933.  
  2934.                                     if(Index > 0)
  2935.                                     {
  2936.                                         Index--;
  2937.  
  2938.                                         if(Echo)
  2939.                                             SerWrite(&Temp,1);
  2940.                                     }
  2941.  
  2942.                                     break;
  2943.  
  2944.                                 case '\30':
  2945.  
  2946.                                     if(Echo)
  2947.                                     {
  2948.                                         while(Index > 0)
  2949.                                         {
  2950.                                             Index--;
  2951.  
  2952.                                             SerWrite("\b",1);
  2953.                                         }
  2954.                                     }
  2955.                                     else
  2956.                                         Index = 0;
  2957.  
  2958.                                     break;
  2959.  
  2960.                                 default:
  2961.  
  2962.                                     if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2963.                                     {
  2964.                                         Buffer[Index++] = Temp;
  2965.  
  2966.                                         if(Echo)
  2967.                                             SerWrite(&Temp,1);
  2968.                                     }
  2969.  
  2970.                                     break;
  2971.                             }
  2972.                         }
  2973.                     }
  2974.  
  2975.                     DataHold = NULL;
  2976.  
  2977.                     RestartSerial(TRUE);
  2978.                 }
  2979.  
  2980.                 if(CheckSerialRead())
  2981.                     Signals = SIG_SERIAL;
  2982.                 else
  2983.                     Signals = NULL;
  2984.  
  2985.                 do
  2986.                 {
  2987.                     if(Signals & SIG_WINDOW)
  2988.                     {
  2989.                         SerWriteBypass = RexxReadBypassTranslate;
  2990.  
  2991.                         RexxReadBuffer    = Buffer;
  2992.                         RexxReadIndex    = Index;
  2993.                         RexxReadLen    = Len;
  2994.                         RexxReadDone    = Done;
  2995.  
  2996.                         while(HandleWindow());
  2997.  
  2998.                         Buffer    = RexxReadBuffer;
  2999.                         Index    = RexxReadIndex;
  3000.                         Len    = RexxReadLen;
  3001.                         Done    = RexxReadDone;
  3002.  
  3003.                         SerWriteBypass = NULL;
  3004.                     }
  3005.  
  3006.                     if(Signals & SIG_SERIAL)
  3007.                     {
  3008.                         if(!WaitSerialRead())
  3009.                         {
  3010.                             LONG Length;
  3011.  
  3012.                             BytesIn++;
  3013.  
  3014.                             if(Translate_CR_LF)
  3015.                                 Length = (* Translate_CR_LF)(ReadBuffer,1);
  3016.                             else
  3017.                                 Length = 1;
  3018.  
  3019.                             if(Length)
  3020.                             {
  3021.                                 TranslateSetup(&Handle,ReadBuffer,Length,&Temp,1,ReceiveTable);
  3022.  
  3023.                                 while(!Done && TranslateBuffer(&Handle))
  3024.                                 {
  3025.                                     switch(Temp)
  3026.                                     {
  3027.                                         case '\n':
  3028.  
  3029.                                             break;
  3030.  
  3031.                                         case '\r':
  3032.  
  3033.                                             Done = TRUE;
  3034.  
  3035.                                             if(Echo)
  3036.                                                 SerWrite(&Temp,1);
  3037.  
  3038.                                             break;
  3039.  
  3040.                                         case '\b':
  3041.  
  3042.                                             if(Index > 0)
  3043.                                             {
  3044.                                                 Index--;
  3045.  
  3046.                                                 if(Echo)
  3047.                                                     SerWrite(&Temp,1);
  3048.                                             }
  3049.  
  3050.                                             break;
  3051.  
  3052.                                         case '\30':
  3053.  
  3054.                                             if(Echo)
  3055.                                             {
  3056.                                                 while(Index > 0)
  3057.                                                 {
  3058.                                                     Index--;
  3059.  
  3060.                                                     SerWrite("\b",1);
  3061.                                                 }
  3062.                                             }
  3063.                                             else
  3064.                                                 Index = 0;
  3065.  
  3066.                                         default:
  3067.  
  3068.                                             if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  3069.                                             {
  3070.                                                 Buffer[Index++] = Temp;
  3071.  
  3072.                                                 if(Echo)
  3073.                                                     SerWrite(&Temp,1);
  3074.                                             }
  3075.  
  3076.                                             break;
  3077.                                     }
  3078.                                 }
  3079.                             }
  3080.                         }
  3081.  
  3082.                         RestartSerial(TRUE);
  3083.                     }
  3084.  
  3085.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  3086.                     {
  3087.                         Results[0] = RC_WARN;
  3088.  
  3089.                         break;
  3090.                     }
  3091.  
  3092.                     if(!Done)
  3093.                         Signals = Wait(SignalMask | SIG_WINDOW);
  3094.                 }
  3095.                 while(!Done);
  3096.  
  3097.                 if(RexxTimeoutVal)
  3098.                     StopTime();
  3099.  
  3100.                 if(Index)
  3101.                 {
  3102.                     STRPTR Result;
  3103.  
  3104.                     Buffer[Index] = 0;
  3105.  
  3106.                     Result = CreateResult(Buffer,Results);
  3107.  
  3108.                     if(Args[ARG_READ_CR])
  3109.                     {
  3110.                         Forbid();
  3111.  
  3112.                         Window -> Flags &= ~WFLG_RMBTRAP;
  3113.  
  3114.                         LT_LockWindow(Window);
  3115.  
  3116.                         Permit();
  3117.                     }
  3118.  
  3119.                     ReleaseWindows();
  3120.  
  3121.                     FreeVecPooled(Buffer);
  3122.  
  3123.                     return(Result);
  3124.                 }
  3125.                 else
  3126.                     Results[0] = RC_WARN;
  3127.  
  3128.                 FreeVecPooled(Buffer);
  3129.             }
  3130.             else
  3131.             {
  3132.                 Results[0] = RC_ERROR;
  3133.                 Results[1] = ERROR_NO_FREE_STORE;
  3134.             }
  3135.         }
  3136.         else
  3137.         {
  3138.             STRPTR Buffer;
  3139.  
  3140.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  3141.             {
  3142.                 STRPTR Result;
  3143.  
  3144.                 if(DataHold && DataSize >= Len - 1)
  3145.                 {
  3146.                     CopyMem(DataHold,Buffer,Len - 1);
  3147.  
  3148.                     BytesRead = Len - 1;
  3149.  
  3150.                     if(DataSize == Len - 1)
  3151.                     {
  3152.                         DataHold = NULL;
  3153.  
  3154.                         RestartSerial(TRUE);
  3155.                     }
  3156.                     else
  3157.                     {
  3158.                         DataHold += Len - 1;
  3159.                         DataSize -= Len - 1;
  3160.                     }
  3161.                 }
  3162.                 else
  3163.                 {
  3164.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  3165.  
  3166.                     ClearSerial();
  3167.  
  3168.                     ClrSignal(SignalMask);
  3169.  
  3170.                     if(RexxTimeoutVal)
  3171.                         StartTime(RexxTimeoutVal,0);
  3172.  
  3173.                     if(DataHold)
  3174.                     {
  3175.                         CopyMem(DataHold,Buffer,DataSize);
  3176.  
  3177.                         StartSerialRead(Buffer + DataSize,Len - 1 - DataSize);
  3178.  
  3179.                         BytesRead = DataSize;
  3180.  
  3181.                         DataHold = NULL;
  3182.                     }
  3183.                     else
  3184.                         StartSerialRead(Buffer,Len - 1);
  3185.  
  3186.                     FOREVER
  3187.                     {
  3188.                         Signals = Wait(SignalMask);
  3189.  
  3190.                         if(Signals & SIG_SERIAL)
  3191.                         {
  3192.                             if(RexxTimeoutVal)
  3193.                                 StopTime();
  3194.  
  3195.                                 /* Did the request terminate gracefully? */
  3196.  
  3197.                             if(!WaitSerialRead())
  3198.                             {
  3199.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3200.  
  3201.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3202.                             }
  3203.                             else
  3204.                                 Results[0] = RC_ERROR;
  3205.  
  3206.                             break;
  3207.                         }
  3208.  
  3209.                         if(Signals & SIG_BREAK)
  3210.                         {
  3211.                             StopSerialRead();
  3212.  
  3213.                             if(RexxTimeoutVal)
  3214.                                 StopTime();
  3215.  
  3216.                             Results[0] = RC_WARN;
  3217.  
  3218.                             break;
  3219.                         }
  3220.  
  3221.                         if(Signals & SIG_TIMER)
  3222.                         {
  3223.                             StopSerialRead();
  3224.  
  3225.                             WaitIO(TimeRequest);
  3226.  
  3227.                             if(ReadRequest -> IOSer . io_Actual)
  3228.                             {
  3229.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3230.  
  3231.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3232.                             }
  3233.                             else
  3234.                             {
  3235.                                 ULONG Waiting = GetSerialWaiting();
  3236.  
  3237.                                 if(Waiting)
  3238.                                 {
  3239.                                         /* Don't read more than actually wanted. */
  3240.  
  3241.                                     if(!DoSerialRead(Buffer,MIN(Len - 1,Waiting)))
  3242.                                     {
  3243.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  3244.  
  3245.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  3246.                                     }
  3247.                                 }
  3248.                             }
  3249.  
  3250.                             break;
  3251.                         }
  3252.                     }
  3253.                 }
  3254.  
  3255.                 if(BytesRead)
  3256.                 {
  3257.                     STRPTR MetaBuffer;
  3258.  
  3259.                     if(MetaBuffer = AllocVecPooled(Len,MEMF_ANY))
  3260.                     {
  3261.                         struct TranslationHandle    Handle;
  3262.                         LONG                Bytes;
  3263.  
  3264.                         TranslateSetup(&Handle,Buffer,BytesRead,MetaBuffer,Len - 1,ReceiveTable);
  3265.  
  3266.                         Bytes = TranslateBuffer(&Handle);
  3267.  
  3268.                         Result = CreateResultLen(MetaBuffer,Results,Bytes);
  3269.  
  3270.                         FreeVecPooled(MetaBuffer);
  3271.                     }
  3272.                     else
  3273.                     {
  3274.                         Results[0] = RC_ERROR;
  3275.                         Results[1] = ERROR_NO_FREE_STORE;
  3276.  
  3277.                         Result = NULL;
  3278.                     }
  3279.                 }
  3280.                 else
  3281.                 {
  3282.                     Results[0] = RC_WARN;
  3283.  
  3284.                     Result = NULL;
  3285.                 }
  3286.  
  3287.                 FreeVecPooled(Buffer);
  3288.  
  3289.                 RestartSerial(TRUE);
  3290.  
  3291.                 if(Args[ARG_READ_CR])
  3292.                 {
  3293.                     Forbid();
  3294.  
  3295.                     Window -> Flags &= ~WFLG_RMBTRAP;
  3296.  
  3297.                     LT_LockWindow(Window);
  3298.  
  3299.                     Permit();
  3300.                 }
  3301.  
  3302.                 ReleaseWindows();
  3303.  
  3304.                 return(Result);
  3305.             }
  3306.             else
  3307.             {
  3308.                 Results[0] = RC_ERROR;
  3309.                 Results[1] = ERROR_NO_FREE_STORE;
  3310.             }
  3311.  
  3312.             RestartSerial(TRUE);
  3313.         }
  3314.     }
  3315.  
  3316.     if(Args[ARG_READ_CR])
  3317.     {
  3318.         Forbid();
  3319.  
  3320.         Window -> Flags &= ~WFLG_RMBTRAP;
  3321.  
  3322.         LT_LockWindow(Window);
  3323.  
  3324.         Permit();
  3325.     }
  3326.  
  3327.     ReleaseWindows();
  3328.  
  3329.     return(NULL);
  3330. }
  3331.  
  3332. STRPTR
  3333. RexxReceiveFile(struct RexxPkt *Pkt)
  3334. {
  3335.     enum    {    ARG_RECEIVEFILE_MODE,ARG_RECEIVEFILE_NAME };
  3336.  
  3337.     WORD Mode = TRANSFER_BINARY;
  3338.  
  3339.     if(Args[ARG_RECEIVEFILE_MODE])
  3340.         Mode = ToMode(Args[ARG_RECEIVEFILE_MODE]);
  3341.  
  3342.     if(Mode == -1)
  3343.     {
  3344.         Results[0] = RC_ERROR;
  3345.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  3346.     }
  3347.     else
  3348.     {
  3349.         BlockWindows();
  3350.  
  3351.         switch(Mode)
  3352.         {
  3353.             case TRANSFER_ASCII:
  3354.  
  3355.                 if(ChangeProtocol(Config -> TransferConfig -> ASCIIDownloadLibrary,Config -> TransferConfig -> ASCIIDownloadType))
  3356.                 {
  3357.                     BinaryTransfer = FALSE;
  3358.  
  3359.                     StartXprReceive(TRANSFER_ASCII,NULL,FALSE);
  3360.  
  3361.                     BinaryTransfer = TRUE;
  3362.  
  3363.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3364.                 }
  3365.                 else
  3366.                 {
  3367.                     Results[0] = RC_ERROR;
  3368.                     Results[1] = ERROR_NO_FREE_STORE;
  3369.                 }
  3370.  
  3371.                 ResetProtocol();
  3372.  
  3373.                 break;
  3374.  
  3375.             case TRANSFER_TEXT:
  3376.  
  3377.                 if(ChangeProtocol(Config -> TransferConfig -> TextDownloadLibrary,Config -> TransferConfig -> TextDownloadType))
  3378.                 {
  3379.                     BinaryTransfer = FALSE;
  3380.  
  3381.                     StartXprReceive(TRANSFER_TEXT,NULL,FALSE);
  3382.  
  3383.                     BinaryTransfer = TRUE;
  3384.  
  3385.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3386.                 }
  3387.                 else
  3388.                 {
  3389.                     Results[0] = RC_ERROR;
  3390.                     Results[1] = ERROR_NO_FREE_STORE;
  3391.                 }
  3392.  
  3393.                 ResetProtocol();
  3394.  
  3395.                 break;
  3396.  
  3397.             case TRANSFER_BINARY:
  3398.  
  3399.                 if(ChangeProtocol(Config -> TransferConfig -> BinaryDownloadLibrary,Config -> TransferConfig -> BinaryDownloadType))
  3400.                 {
  3401.                     BinaryTransfer = TRUE;
  3402.  
  3403.                     StartXprReceive(TRANSFER_BINARY,NULL,FALSE);
  3404.  
  3405.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3406.                 }
  3407.                 else
  3408.                 {
  3409.                     Results[0] = RC_ERROR;
  3410.                     Results[1] = ERROR_NO_FREE_STORE;
  3411.                 }
  3412.  
  3413.                 ResetProtocol();
  3414.  
  3415.                 break;
  3416.         }
  3417.  
  3418.         if(TransferFailed)
  3419.             Results[0] = RC_ERROR;
  3420.  
  3421.         if(TransferAborted)
  3422.             Results[0] = RC_WARN;
  3423.  
  3424.         ReleaseWindows();
  3425.     }
  3426.  
  3427.     return(NULL);
  3428. }
  3429.  
  3430. STRPTR
  3431. RexxRedial(struct RexxPkt *Pkt)
  3432. {
  3433.     if(DialList)
  3434.     {
  3435.         if(DialList -> lh_Head -> ln_Succ)
  3436.             DoDial = DIAL_REDIAL;
  3437.         else
  3438.             Results[0] = RC_WARN;
  3439.     }
  3440.     else
  3441.         Results[0] = RC_WARN;
  3442.  
  3443.     return(NULL);
  3444. }
  3445.  
  3446. STRPTR
  3447. RexxRemove(struct RexxPkt *Pkt)
  3448. {
  3449.     enum    {    ARG_REMOVE_FROM,ARG_REMOVE_NAME };
  3450.  
  3451.     WORD Index;
  3452.  
  3453.     if((Index = ToList(Args[ARG_REMOVE_FROM])) == -1)
  3454.     {
  3455.         Results[0] = RC_ERROR;
  3456.         Results[1] = TERMERROR_UNKNOWN_LIST;
  3457.     }
  3458.     else
  3459.     {
  3460.         if(Args[ARG_REMOVE_NAME] && Index == GLIST_DIAL)
  3461.         {
  3462.             Results[0] = RC_ERROR;
  3463.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  3464.         }
  3465.         else
  3466.         {
  3467.             struct GenericList *List;
  3468.  
  3469.             List = GenericListTable[Index];
  3470.  
  3471.             if(Args[ARG_REMOVE_NAME])
  3472.             {
  3473.                 STRPTR Buffer;
  3474.  
  3475.                 if(Buffer = CreateMatchBuffer(Args[ARG_REMOVE_NAME]))
  3476.                 {
  3477.                     struct Node *Node,*NextNode;
  3478.  
  3479.                     ObtainSemaphore(&List -> ListSemaphore);
  3480.  
  3481.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  3482.  
  3483.                     while(NextNode = Node -> ln_Succ)
  3484.                     {
  3485.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  3486.                         {
  3487.                             Forbid();
  3488.  
  3489.                             ReleaseSemaphore(&List -> ListSemaphore);
  3490.  
  3491.                             DeleteGenericListNode(List,Node);
  3492.  
  3493.                             ObtainSemaphore(&List -> ListSemaphore);
  3494.  
  3495.                             Permit();
  3496.                         }
  3497.  
  3498.                         Node = NextNode;
  3499.                     }
  3500.  
  3501.                     ReleaseSemaphore(&List -> ListSemaphore);
  3502.  
  3503.                     DeleteMatchBuffer(Buffer);
  3504.                 }
  3505.                 else
  3506.                 {
  3507.                     Results[0] = RC_ERROR;
  3508.                     Results[1] = ERROR_NO_FREE_STORE;
  3509.                 }
  3510.             }
  3511.             else
  3512.                 DeleteGenericListNode(List,NULL);
  3513.  
  3514.             if(!GenericListCount(List))
  3515.                 Results[0] = RC_WARN;
  3516.         }
  3517.     }
  3518.  
  3519.     return(NULL);
  3520. }
  3521.  
  3522. STRPTR
  3523. RexxRequestFile(struct RexxPkt *Pkt)
  3524. {
  3525.     enum    {    ARG_REQUESTFILE_TITLE,ARG_REQUESTFILE_PATH,ARG_REQUESTFILE_FILE,
  3526.             ARG_REQUESTFILE_PATTERN,ARG_REQUESTFILE_MULTI,ARG_REQUESTFILE_NAME };
  3527.  
  3528.     if(Args[ARG_REQUESTFILE_MULTI] && !Args[ARG_REQUESTFILE_NAME])
  3529.     {
  3530.         Results[0] = RC_ERROR;
  3531.         Results[1] = TERMERROR_RESULT_VARIABLE_REQUIRED;
  3532.     }
  3533.     else
  3534.     {
  3535.         struct FileRequester    *FileRequester;
  3536.         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  3537.                     *DummyChar;
  3538.         STRPTR             FileName,
  3539.                      PathName;
  3540.  
  3541.         if(Args[ARG_REQUESTFILE_PATH])
  3542.         {
  3543.             PathName = Args[ARG_REQUESTFILE_PATH];
  3544.  
  3545.             if(Args[ARG_REQUESTFILE_FILE])
  3546.                 FileName = Args[ARG_REQUESTFILE_FILE];
  3547.             else
  3548.                 FileName = "";
  3549.         }
  3550.         else
  3551.         {
  3552.             PathName = "";
  3553.  
  3554.             if(Args[ARG_REQUESTFILE_FILE])
  3555.             {
  3556.                 strcpy(DummyBuffer,Args[ARG_REQUESTFILE_FILE]);
  3557.  
  3558.                 DummyChar = PathPart(DummyBuffer);
  3559.  
  3560.                 *DummyChar = 0;
  3561.  
  3562.                 PathName = DummyBuffer;
  3563.                 FileName = FilePart(Args[ARG_REQUESTFILE_FILE]);
  3564.             }
  3565.             else
  3566.                 FileName = "";
  3567.         }
  3568.  
  3569.         BlockWindows();
  3570.  
  3571.         if(FileRequester = GetFile(Window,Args[ARG_REQUESTFILE_TITLE],PathName,FileName,DummyBuffer,Args[ARG_REQUESTFILE_PATTERN],FALSE,Args[ARG_REQUESTFILE_MULTI] != NULL,FALSE,"Ok",TRUE))
  3572.         {
  3573.             if(Args[ARG_REQUESTFILE_NAME])
  3574.             {
  3575.                 if(Args[ARG_REQUESTFILE_MULTI])
  3576.                 {
  3577.                     UBYTE         DummyBuffer[MAX_FILENAME_LENGTH];
  3578.                     struct WBArg    *ArgList = FileRequester -> rf_ArgList;
  3579.                     LONG         i,Counted = 0;
  3580.  
  3581.                     for(i = 0 ; i < FileRequester -> rf_NumArgs ; i++)
  3582.                     {
  3583.                         if(ArgList[i] . wa_Name)
  3584.                         {
  3585.                             if(ArgList[i] . wa_Lock)
  3586.                             {
  3587.                                 if(!NameFromLock(ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  3588.                                 {
  3589.                                     Results[0] = RC_ERROR;
  3590.                                     Results[1] = IoErr();
  3591.  
  3592.                                     break;
  3593.                                 }
  3594.                             }
  3595.                             else
  3596.                                 strcpy(DummyBuffer,FileRequester -> rf_Dir);
  3597.  
  3598.                             if(AddPart(DummyBuffer,ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  3599.                             {
  3600.                                 if(CreateVarArgs(DummyBuffer,Pkt,"%s.%ld",Args[ARG_REQUESTFILE_NAME],i))
  3601.                                     Counted++;
  3602.                                 else
  3603.                                     break;
  3604.                             }
  3605.                             else
  3606.                             {
  3607.                                 Results[0] = RC_ERROR;
  3608.                                 Results[1] = IoErr();
  3609.  
  3610.                                 break;
  3611.                             }
  3612.                         }
  3613.                     }
  3614.  
  3615.                     if(Counted)
  3616.                     {
  3617.                         SPrintf(DummyBuffer,"%ld",Counted);
  3618.  
  3619.                         CreateVarArgs(DummyBuffer,Pkt,"%s.COUNT",Args[ARG_REQUESTFILE_NAME]);
  3620.                     }
  3621.  
  3622.                     FreeAslRequest(FileRequester);
  3623.                 }
  3624.                 else
  3625.                 {
  3626.                     FreeAslRequest(FileRequester);
  3627.  
  3628.                     ReleaseWindows();
  3629.  
  3630.                     return(CreateVar(DummyBuffer,Pkt,Args[ARG_REQUESTFILE_NAME]));
  3631.                 }
  3632.             }
  3633.             else
  3634.             {
  3635.                 FreeAslRequest(FileRequester);
  3636.  
  3637.                 ReleaseWindows();
  3638.  
  3639.                 return(CreateResult(DummyBuffer,Results));
  3640.             }
  3641.         }
  3642.         else
  3643.             Results[0] = RC_WARN;
  3644.  
  3645.         ReleaseWindows();
  3646.     }
  3647.  
  3648.     return(NULL);
  3649. }
  3650.  
  3651. STRPTR
  3652. RexxRequestNotify(struct RexxPkt *Pkt)
  3653. {
  3654.     enum    {    ARG_REQUESTNOTIFY_TITLE,ARG_REQUESTNOTIFY_PROMPT };
  3655.  
  3656.     struct EasyStruct    Easy;
  3657.     ULONG            IDCMP = NULL;
  3658.  
  3659.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3660.     Easy . es_Flags        = NULL;
  3661.     Easy . es_TextFormat    = Args[ARG_REQUESTNOTIFY_PROMPT];
  3662.     Easy . es_GadgetFormat    = LocaleString(MSG_GLOBAL_CONTINUE_TXT);
  3663.  
  3664.     if(Args[ARG_REQUESTNOTIFY_TITLE])
  3665.         Easy . es_Title    = Args[ARG_REQUESTNOTIFY_TITLE];
  3666.     else
  3667.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3668.  
  3669.     BlockWindows();
  3670.  
  3671.     EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3672.  
  3673.     ReleaseWindows();
  3674.  
  3675.     return(NULL);
  3676. }
  3677.  
  3678. STRPTR
  3679. RexxRequestNumber(struct RexxPkt *Pkt)
  3680. {
  3681.     enum    {    ARG_REQUESTNUMBER_DEFAULT,ARG_REQUESTNUMBER_PROMPT };
  3682.  
  3683.     UBYTE DummyBuffer[256];
  3684.  
  3685.     if(Args[ARG_REQUESTNUMBER_DEFAULT])
  3686.         SPrintf(DummyBuffer,"%ld",*(LONG *)Args[ARG_REQUESTNUMBER_DEFAULT]);
  3687.     else
  3688.         DummyBuffer[0] = 0;
  3689.  
  3690.     BlockWindows();
  3691.  
  3692.     if(GetString(FALSE,FALSE,255,Args[ARG_REQUESTNUMBER_PROMPT],DummyBuffer))
  3693.     {
  3694.         STRPTR Index = DummyBuffer;
  3695.  
  3696.         while(*Index == ' ' || *Index == '\t')
  3697.             Index++;
  3698.  
  3699.         if(*Index)
  3700.         {
  3701.             LONG Value;
  3702.  
  3703.             if(StrToLong(DummyBuffer,&Value) == -1)
  3704.             {
  3705.                 Results[0] = RC_ERROR;
  3706.                 Results[1] = ERROR_BAD_NUMBER;
  3707.             }
  3708.             else
  3709.             {
  3710.                 ReleaseWindows();
  3711.  
  3712.                 SPrintf(DummyBuffer,"%ld",Value);
  3713.  
  3714.                 return(CreateResult(DummyBuffer,Results));
  3715.             }
  3716.         }
  3717.         else
  3718.             Results[0] = RC_WARN;
  3719.     }
  3720.     else
  3721.         Results[0] = RC_WARN;
  3722.  
  3723.     ReleaseWindows();
  3724.  
  3725.     return(NULL);
  3726. }
  3727.  
  3728. STRPTR
  3729. RexxRequestResponse(struct RexxPkt *Pkt)
  3730. {
  3731.     enum    {    ARG_REQUESTRESPONSE_TITLE,ARG_REQUESTRESPONSE_OPTIONS,
  3732.             ARG_REQUESTRESPONSE_PROMPT };
  3733.  
  3734.     struct EasyStruct    Easy;
  3735.     ULONG            IDCMP = NULL;
  3736.     WORD            Result;
  3737.  
  3738.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3739.     Easy . es_Flags        = NULL;
  3740.     Easy . es_TextFormat    = Args[ARG_REQUESTRESPONSE_PROMPT];
  3741.  
  3742.     if(Args[ARG_REQUESTRESPONSE_OPTIONS])
  3743.         Easy . es_GadgetFormat = Args[ARG_REQUESTRESPONSE_OPTIONS];
  3744.     else
  3745.         Easy . es_GadgetFormat = LocaleString(MSG_GLOBAL_YES_NO_TXT);
  3746.  
  3747.     if(Args[ARG_REQUESTRESPONSE_TITLE])
  3748.         Easy . es_Title    = Args[ARG_REQUESTRESPONSE_TITLE];
  3749.     else
  3750.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3751.  
  3752.     BlockWindows();
  3753.  
  3754.     Result = EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3755.  
  3756.     ReleaseWindows();
  3757.  
  3758.     if(Result)
  3759.     {
  3760.         UBYTE DummyBuffer[20];
  3761.  
  3762.         SPrintf(DummyBuffer,"%ld",Result);
  3763.  
  3764.         return(CreateResult(DummyBuffer,Results));
  3765.     }
  3766.     else
  3767.     {
  3768.         Results[0] = RC_WARN;
  3769.  
  3770.         return(NULL);
  3771.     }
  3772. }
  3773.  
  3774. STRPTR
  3775. RexxRequestString(struct RexxPkt *Pkt)
  3776. {
  3777.     enum    {    ARG_REQUESTSTRING_SECRET,ARG_REQUESTSTRING_DEFAULT,ARG_REQUESTSTRING_PROMPT };
  3778.  
  3779.     UBYTE DummyBuffer[256];
  3780.  
  3781.     if(Args[ARG_REQUESTSTRING_DEFAULT])
  3782.         strcpy(DummyBuffer,Args[ARG_REQUESTSTRING_DEFAULT]);
  3783.     else
  3784.         DummyBuffer[0] = 0;
  3785.  
  3786.     BlockWindows();
  3787.  
  3788.     if(GetString(FALSE,Args[ARG_REQUESTSTRING_SECRET] != NULL,255,Args[ARG_REQUESTSTRING_PROMPT],DummyBuffer))
  3789.     {
  3790.         ReleaseWindows();
  3791.  
  3792.         return(CreateResult(DummyBuffer,Results));
  3793.     }
  3794.     else
  3795.         Results[0] = RC_WARN;
  3796.  
  3797.     ReleaseWindows();
  3798.  
  3799.     return(NULL);
  3800. }
  3801.  
  3802. STRPTR
  3803. RexxResetScreen(struct RexxPkt *Pkt)
  3804. {
  3805.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3806.         XEmulatorResetConsole(XEM_IO);
  3807.     else
  3808.     {
  3809.         FreeMarker();
  3810.  
  3811.         ObtainSemaphore(&TerminalSemaphore);
  3812.  
  3813.         ClearCursor();
  3814.  
  3815.         Reset();
  3816.  
  3817.         DrawCursor();
  3818.  
  3819.         ReleaseSemaphore(&TerminalSemaphore);
  3820.     }
  3821.  
  3822.     return(NULL);
  3823. }
  3824.  
  3825. STRPTR
  3826. RexxResetStyles(struct RexxPkt *Pkt)
  3827. {
  3828.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3829.         XEmulatorResetTextStyles(XEM_IO);
  3830.     else
  3831.     {
  3832.         DropMarker();
  3833.  
  3834.         ConBypass("\033[0m",-1);
  3835.  
  3836.         ObtainSemaphore(&TerminalSemaphore);
  3837.  
  3838.         ClearCursor();
  3839.  
  3840.         Config -> EmulationConfig -> FontScale = SCALE_NORMAL;
  3841.  
  3842.         ForegroundPen = GetPenIndex(SafeTextPen);
  3843.         BackgroundPen = 0;
  3844.  
  3845.         UpdatePens();
  3846.  
  3847.         SetMask(RPort,DepthMask);
  3848.  
  3849.         ConFontScaleUpdate();
  3850.  
  3851.         DrawCursor();
  3852.  
  3853.         ReleaseSemaphore(&TerminalSemaphore);
  3854.     }
  3855.  
  3856.     return(NULL);
  3857. }
  3858.  
  3859. STRPTR
  3860. RexxResetText(struct RexxPkt *Pkt)
  3861. {
  3862.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3863.         XEmulatorResetCharset(XEM_IO);
  3864.     else
  3865.     {
  3866.         DropMarker();
  3867.  
  3868.         CurrentFont = TextFont;
  3869.  
  3870.         SetFont(RPort,CurrentFont);
  3871.  
  3872.         ConOutputUpdate();
  3873.     }
  3874.  
  3875.     return(NULL);
  3876. }
  3877.  
  3878. STRPTR
  3879. RexxResetTimer(struct RexxPkt *Pkt)
  3880. {
  3881.     Forbid();
  3882.  
  3883.     if(StatusProcess)
  3884.         Signal(StatusProcess,SIG_RESETTIME);
  3885.  
  3886.     Permit();
  3887.  
  3888.     return(NULL);
  3889. }
  3890.  
  3891. STRPTR
  3892. RexxSaveAs(struct RexxPkt *Pkt)
  3893. {
  3894.     enum    {    ARG_SAVEAS_NAME,ARG_SAVEAS_FROM };
  3895.  
  3896.     WORD Index = ToConfig(Args[ARG_SAVEAS_FROM]);
  3897.  
  3898.     if(Index == -1)
  3899.     {
  3900.         Results[0] = RC_ERROR;
  3901.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  3902.     }
  3903.     else
  3904.     {
  3905.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  3906.         STRPTR    FileName;
  3907.  
  3908.         if(Args[ARG_SAVEAS_NAME])
  3909.             FileName = Args[ARG_SAVEAS_NAME];
  3910.         else
  3911.         {
  3912.             STRPTR             Title;
  3913.             struct FileRequester    *FileRequest;
  3914.  
  3915.             FileName = NULL;
  3916.  
  3917.             switch(Index)
  3918.             {
  3919.                 case DATATYPE_TRANSLATIONS:
  3920.  
  3921.                     Title = LocaleString(MSG_TRANSLATIONPANEL_SAVE_TRANSLATION_TABLES_TXT);
  3922.                     break;
  3923.  
  3924.                 case DATATYPE_FUNCTIONKEYS:
  3925.  
  3926.                     Title = LocaleString(MSG_MACROPANEL_SAVE_MACRO_KEYS_TXT);
  3927.                     break;
  3928.  
  3929.                 case DATATYPE_CURSORKEYS:
  3930.  
  3931.                     Title = LocaleString(MSG_CURSORPANEL_SAVE_CURSOR_KEYS_TXT);
  3932.                     break;
  3933.  
  3934.                 case DATATYPE_FASTMACROS:
  3935.  
  3936.                     Title = LocaleString(MSG_FASTMACROPANEL_SAVE_FAST_MACRO_SETTINGS_TXT);
  3937.                     break;
  3938.  
  3939.                 case DATATYPE_HOTKEYS:
  3940.  
  3941.                     Title = LocaleString(MSG_HOTKEYPANEL_SAVE_HOTKEYS_TXT);
  3942.                     break;
  3943.  
  3944.                 case DATATYPE_SPEECH:
  3945.  
  3946.                     Title = LocaleString(MSG_SPEECHPANEL_SAVE_SPEECH_SETTINGS_TXT);
  3947.                     break;
  3948.  
  3949.                 case DATATYPE_SOUND:
  3950.  
  3951.                     Title = LocaleString(MSG_SOUNDPANEL_SAVE_SOUNDS_TXT);
  3952.                     break;
  3953.  
  3954.                 case DATATYPE_BUFFER:
  3955.  
  3956.                     Title = LocaleString(MSG_TERMMAIN_SAVE_BUFFER_TXT);
  3957.                     break;
  3958.  
  3959.                 case DATATYPE_CONFIGURATION:
  3960.  
  3961.                     Title = LocaleString(MSG_TERMMAIN_SAVE_PREFERENCES_AS_TXT);
  3962.                     break;
  3963.  
  3964.                 case DATATYPE_PHONEBOOK:
  3965.  
  3966.                     Title = LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT);
  3967.                     break;
  3968.  
  3969.                 case DATATYPE_SCREENTEXT:
  3970.  
  3971.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_ASCII_TXT);
  3972.                     break;
  3973.  
  3974.                 case DATATYPE_SCREENIMAGE:
  3975.  
  3976.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_IFF_TXT);
  3977.                     break;
  3978.             }
  3979.  
  3980.             BlockWindows();
  3981.  
  3982.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,TRUE,FALSE,FALSE,NULL,TRUE))
  3983.             {
  3984.                 FileName = DummyBuffer;
  3985.  
  3986.                 FreeAslRequest(FileRequest);
  3987.             }
  3988.  
  3989.             ReleaseWindows();
  3990.         }
  3991.  
  3992.         if(FileName)
  3993.         {
  3994.             switch(Index)
  3995.             {
  3996.                 case DATATYPE_TRANSLATIONS:
  3997.                 {
  3998.                     if(SendTable && ReceiveTable)
  3999.                     {
  4000.                         if(!SaveTranslationTables(FileName,SendTable,ReceiveTable))
  4001.                         {
  4002.                             Results[0] = RC_ERROR;
  4003.                             Results[1] = IoErr();
  4004.                         }
  4005.                         else
  4006.                         {
  4007.                             strcpy(LastTranslation,FileName);
  4008.  
  4009.                             TranslationChanged = FALSE;
  4010.                         }
  4011.                     }
  4012.                     else
  4013.                         Results[0] = RC_WARN;
  4014.                 }
  4015.  
  4016.                 break;
  4017.  
  4018.                 case DATATYPE_FUNCTIONKEYS:
  4019.                 {
  4020.                     if(!WriteIFFData(FileName,MacroKeys,sizeof(struct MacroKeys),ID_KEYS))
  4021.                     {
  4022.                         Results[0] = RC_ERROR;
  4023.                         Results[1] = IoErr();
  4024.                     }
  4025.                     else
  4026.                     {
  4027.                         strcpy(LastMacros,FileName);
  4028.  
  4029.                         MacroChanged = FALSE;
  4030.                     }
  4031.                 }
  4032.  
  4033.                 break;
  4034.  
  4035.                 case DATATYPE_CURSORKEYS:
  4036.                 {
  4037.                     if(!WriteIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  4038.                     {
  4039.                         Results[0] = RC_ERROR;
  4040.                         Results[1] = IoErr();
  4041.                     }
  4042.                     else
  4043.                     {
  4044.                         strcpy(LastCursorKeys,FileName);
  4045.  
  4046.                         CursorKeysChanged = FALSE;
  4047.                     }
  4048.                 }
  4049.  
  4050.                 break;
  4051.  
  4052.                 case DATATYPE_FASTMACROS:
  4053.                 {
  4054.                     if(!SaveFastMacros(FileName,&FastMacroList))
  4055.                     {
  4056.                         Results[0] = RC_ERROR;
  4057.                         Results[1] = IoErr();
  4058.                     }
  4059.                     else
  4060.                     {
  4061.                         strcpy(LastFastMacros,FileName);
  4062.  
  4063.                         FastMacrosChanged = FALSE;
  4064.                     }
  4065.                 }
  4066.  
  4067.                 break;
  4068.  
  4069.                 case DATATYPE_HOTKEYS:
  4070.                 {
  4071.                     if(!WriteIFFData(FileName,&Hotkeys,sizeof(struct Hotkeys),ID_HOTK))
  4072.                     {
  4073.                         Results[0] = RC_ERROR;
  4074.                         Results[1] = IoErr();
  4075.                     }
  4076.                     else
  4077.                     {
  4078.                         strcpy(LastKeys,FileName);
  4079.  
  4080.                         HotkeysChanged = FALSE;
  4081.                     }
  4082.                 }
  4083.  
  4084.                 break;
  4085.  
  4086.                 case DATATYPE_SPEECH:
  4087.                 {
  4088.                     if(!WriteIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  4089.                     {
  4090.                         Results[0] = RC_ERROR;
  4091.                         Results[1] = IoErr();
  4092.                     }
  4093.                     else
  4094.                     {
  4095.                         strcpy(LastSpeech,FileName);
  4096.  
  4097.                         SpeechChanged = FALSE;
  4098.                     }
  4099.                 }
  4100.  
  4101.                 break;
  4102.  
  4103.                 case DATATYPE_SOUND:
  4104.                 {
  4105.                     if(!WriteIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  4106.                     {
  4107.                         Results[0] = RC_ERROR;
  4108.                         Results[1] = IoErr();
  4109.                     }
  4110.                     else
  4111.                     {
  4112.                         strcpy(LastSound,FileName);
  4113.  
  4114.                         SoundChanged = FALSE;
  4115.                     }
  4116.                 }
  4117.  
  4118.                 break;
  4119.  
  4120.                 case DATATYPE_BUFFER:
  4121.                 {
  4122.                     if(BufferLines && Lines)
  4123.                     {
  4124.                         BPTR SomeFile;
  4125.  
  4126.                         if(GetFileSize(FileName))
  4127.                         {
  4128.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4129.                             {
  4130.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4131.                                 {
  4132.                                     Close(SomeFile);
  4133.  
  4134.                                     SomeFile = NULL;
  4135.  
  4136.                                     SetIoErr(ERROR_SEEK_ERROR);
  4137.                                 }
  4138.                             }
  4139.                         }
  4140.                         else
  4141.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4142.  
  4143.                         if(SomeFile)
  4144.                         {
  4145.                             LONG i,Len;
  4146.  
  4147.                                 /* Obtain the semaphore required
  4148.                                  * to gain access to the line buffer
  4149.                                  */
  4150.  
  4151.                             ObtainSemaphore(BufferSemaphore);
  4152.  
  4153.                             for(i = 0 ; i < Lines ; i++)
  4154.                             {
  4155.                                 Len = BufferLines[i][-1];
  4156.  
  4157.                                 if(Len)
  4158.                                 {
  4159.                                     if(FWrite(SomeFile,BufferLines[i],Len,1) != 1)
  4160.                                     {
  4161.                                         Results[0] = RC_ERROR;
  4162.                                         Results[1] = IoErr();
  4163.  
  4164.                                         break;
  4165.                                     }
  4166.                                 }
  4167.  
  4168.                                 if(FPrintf(SomeFile,"\n") < 1)
  4169.                                 {
  4170.                                     Results[0] = RC_ERROR;
  4171.                                     Results[1] = IoErr();
  4172.  
  4173.                                     break;
  4174.                                 }
  4175.                             }
  4176.  
  4177.                             ReleaseSemaphore(BufferSemaphore);
  4178.  
  4179.                             Close(SomeFile);
  4180.  
  4181.                             AddProtection(FileName,FIBF_EXECUTE);
  4182.  
  4183.                             if(Config -> MiscConfig -> CreateIcons)
  4184.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4185.  
  4186.                             BufferChanged = FALSE;
  4187.                         }
  4188.                         else
  4189.                         {
  4190.                             Results[0] = RC_ERROR;
  4191.                             Results[1] = IoErr();
  4192.                         }
  4193.                     }
  4194.                     else
  4195.                     {
  4196.                         Results[0] = RC_ERROR;
  4197.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4198.                     }
  4199.                 }
  4200.  
  4201.                 break;
  4202.  
  4203.                 case DATATYPE_CONFIGURATION:
  4204.                 {
  4205.                     if(!WriteConfig(FileName,Config))
  4206.                     {
  4207.                         Results[0] = RC_ERROR;
  4208.                         Results[1] = IoErr();
  4209.                     }
  4210.                     else
  4211.                     {
  4212.                         strcpy(LastConfig,FileName);
  4213.  
  4214.                         ConfigChanged = FALSE;
  4215.                     }
  4216.                 }
  4217.  
  4218.                 break;
  4219.  
  4220.                 case DATATYPE_PHONEBOOK:
  4221.                 {
  4222.                     if(!SavePhonebook(FileName))
  4223.                     {
  4224.                         Results[0] = RC_ERROR;
  4225.                         Results[1] = IoErr();
  4226.                     }
  4227.                     else
  4228.                     {
  4229.                         strcpy(LastPhone,FileName);
  4230.  
  4231.                         PhonebookChanged = FALSE;
  4232.                     }
  4233.                 }
  4234.  
  4235.                 break;
  4236.  
  4237.                 case DATATYPE_SCREENTEXT:
  4238.                 {
  4239.                     if(RasterEnabled)
  4240.                     {
  4241.                         BPTR SomeFile;
  4242.  
  4243.                         if(GetFileSize(FileName))
  4244.                         {
  4245.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4246.                             {
  4247.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4248.                                 {
  4249.                                     Close(SomeFile);
  4250.  
  4251.                                     SomeFile = NULL;
  4252.  
  4253.                                     SetIoErr(ERROR_SEEK_ERROR);
  4254.                                 }
  4255.                             }
  4256.                         }
  4257.                         else
  4258.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4259.  
  4260.                         if(SomeFile)
  4261.                         {
  4262.                             LONG     i,j;
  4263.                             UBYTE    *Buffer;
  4264.  
  4265.                             for(i = 0 ; i < RasterHeight ; i++)
  4266.                             {
  4267.                                 Buffer = &Raster[i * RasterWidth];
  4268.  
  4269.                                 j = LastColumn;
  4270.  
  4271.                                 while(j >= 0 && Buffer[j] == ' ')
  4272.                                     j--;
  4273.  
  4274.                                 if(j >= 0)
  4275.                                 {
  4276.                                     if(!FWrite(SomeFile,Buffer,j + 1,1))
  4277.                                     {
  4278.                                         Results[0] = RC_ERROR;
  4279.                                         Results[1] = IoErr();
  4280.  
  4281.                                         break;
  4282.                                     }
  4283.                                 }
  4284.  
  4285.                                 if(!FWrite(SomeFile,"\n",1,1))
  4286.                                 {
  4287.                                     Results[0] = RC_ERROR;
  4288.                                     Results[1] = IoErr();
  4289.  
  4290.                                     break;
  4291.                                 }
  4292.                             }
  4293.  
  4294.                             Close(SomeFile);
  4295.  
  4296.                             AddProtection(FileName,FIBF_EXECUTE);
  4297.  
  4298.                             if(Config -> MiscConfig -> CreateIcons)
  4299.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4300.                         }
  4301.                         else
  4302.                         {
  4303.                             Results[0] = RC_ERROR;
  4304.                             Results[1] = IoErr();
  4305.                         }
  4306.                     }
  4307.                     else
  4308.                     {
  4309.                         Results[0] = RC_ERROR;
  4310.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4311.                     }
  4312.                 }
  4313.  
  4314.                 break;
  4315.  
  4316.                 case DATATYPE_SCREENIMAGE:
  4317.                 {
  4318.                     if(!SaveWindow(FileName,Window))
  4319.                     {
  4320.                         Results[0] = RC_ERROR;
  4321.                         Results[1] = IoErr();
  4322.                     }
  4323.                 }
  4324.  
  4325.                 break;
  4326.             }
  4327.         }
  4328.         else
  4329.             Results[0] = RC_WARN;
  4330.     }
  4331.  
  4332.     return(NULL);
  4333. }
  4334.  
  4335. STRPTR
  4336. RexxSave(struct RexxPkt *Pkt)
  4337. {
  4338.     enum    {    ARG_SAVE_FROM };
  4339.  
  4340.     Args[1] = Args[ARG_SAVE_FROM];
  4341.     Args[0] = NULL;
  4342.  
  4343.     return(RexxSaveAs(Pkt));
  4344. }
  4345.  
  4346. STRPTR
  4347. RexxSelect(struct RexxPkt *Pkt)
  4348. {
  4349.     enum    {    ARG_SELECT_NAME,ARG_SELECT_FROM,ARG_SELECT_NEXT,ARG_SELECT_PREVIOUS,
  4350.             ARG_SELECT_TOP,ARG_SELECT_BOTTOM };
  4351.  
  4352.     WORD Index;
  4353.  
  4354.     if((Index = ToList(Args[ARG_SELECT_FROM])) == -1)
  4355.     {
  4356.         Results[0] = RC_ERROR;
  4357.         Results[1] = TERMERROR_UNKNOWN_LIST;
  4358.     }
  4359.     else
  4360.     {
  4361.         if(Args[ARG_SELECT_NAME] && Index == GLIST_DIAL)
  4362.         {
  4363.             Results[0] = RC_ERROR;
  4364.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  4365.         }
  4366.         else
  4367.         {
  4368.             struct GenericList *List;
  4369.  
  4370.             List = GenericListTable[Index];
  4371.  
  4372.             if(Args[ARG_SELECT_NAME])
  4373.             {
  4374.                 STRPTR Buffer;
  4375.  
  4376.                 if(Buffer = CreateMatchBuffer(Args[ARG_SELECT_NAME]))
  4377.                 {
  4378.                     struct Node *Node,*NextNode;
  4379.  
  4380.                     ObtainSemaphore(&List -> ListSemaphore);
  4381.  
  4382.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  4383.  
  4384.                     while(NextNode = Node -> ln_Succ)
  4385.                     {
  4386.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  4387.                         {
  4388.                             List -> ListNode = Node;
  4389.  
  4390.                             Node = NULL;
  4391.  
  4392.                             break;
  4393.                         }
  4394.  
  4395.                         Node = NextNode;
  4396.                     }
  4397.  
  4398.                     if(Node)
  4399.                         Results[0] = RC_WARN;
  4400.  
  4401.                     ReleaseSemaphore(&List -> ListSemaphore);
  4402.  
  4403.                     DeleteMatchBuffer(Buffer);
  4404.                 }
  4405.                 else
  4406.                 {
  4407.                     Results[0] = RC_ERROR;
  4408.                     Results[1] = ERROR_NO_FREE_STORE;
  4409.                 }
  4410.             }
  4411.             else
  4412.             {
  4413.                 if(Args[ARG_SELECT_NEXT])
  4414.                 {
  4415.                     if(!NextGenericListNode(List))
  4416.                     {
  4417.                         Results[0] = RC_WARN;
  4418.  
  4419.                         return(NULL);
  4420.                     }
  4421.                 }
  4422.  
  4423.                 if(Args[ARG_SELECT_PREVIOUS])
  4424.                 {
  4425.                     if(!PrevGenericListNode(List))
  4426.                     {
  4427.                         Results[0] = RC_WARN;
  4428.  
  4429.                         return(NULL);
  4430.                     }
  4431.                 }
  4432.  
  4433.                 if(Args[ARG_SELECT_TOP])
  4434.                 {
  4435.                     if(!FirstGenericListNode(List))
  4436.                     {
  4437.                         Results[0] = RC_WARN;
  4438.  
  4439.                         return(NULL);
  4440.                     }
  4441.                 }
  4442.  
  4443.                 if(Args[ARG_SELECT_BOTTOM])
  4444.                 {
  4445.                     if(!LastGenericListNode(List))
  4446.                     {
  4447.                         Results[0] = RC_WARN;
  4448.  
  4449.                         return(NULL);
  4450.                     }
  4451.                 }
  4452.             }
  4453.  
  4454.             ObtainSemaphore(&List -> ListSemaphore);
  4455.  
  4456.             if(List -> ListNode)
  4457.             {
  4458.                 if(Index != GLIST_DIAL)
  4459.                 {
  4460.                     struct Node    *Node = (struct Node *)List -> ListNode;
  4461.                     STRPTR         Result;
  4462.  
  4463.                     Result = CreateResult(Node -> ln_Name,Results);
  4464.  
  4465.                     ReleaseSemaphore(&List -> ListSemaphore);
  4466.  
  4467.                     return(Result);
  4468.                 }
  4469.             }
  4470.             else
  4471.                 Results[0] = RC_WARN;
  4472.  
  4473.             ReleaseSemaphore(&List -> ListSemaphore);
  4474.         }
  4475.     }
  4476.  
  4477.     return(NULL);
  4478. }
  4479.  
  4480. STRPTR
  4481. RexxSend(struct RexxPkt *Pkt)
  4482. {
  4483.     enum    {    ARG_SEND_NOECHO,ARG_SEND_LOCAL,ARG_SEND_LITERAL,ARG_SEND_BYTE,ARG_SEND_TEXT };
  4484.  
  4485.     if(Args[ARG_SEND_LOCAL])
  4486.     {
  4487.         if(!Args[ARG_SEND_NOECHO])
  4488.         {
  4489.             if(Marking)
  4490.                 DropMarker();
  4491.  
  4492.             if(Args[ARG_SEND_TEXT])
  4493.             {
  4494.                 if(Args[ARG_SEND_LITERAL])
  4495.                     ConProcess(Args[ARG_SEND_TEXT],strlen(Args[ARG_SEND_TEXT]));
  4496.                 else
  4497.                     ConsoleCommand(Args[ARG_SEND_TEXT]);
  4498.             }
  4499.             else
  4500.             {
  4501.                 UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4502.  
  4503.                 ConProcess(&Byte,1);
  4504.             }
  4505.         }
  4506.     }
  4507.     else
  4508.     {
  4509.         if(Args[ARG_SEND_NOECHO])
  4510.             Quiet = TRUE;
  4511.  
  4512.         if(Args[ARG_SEND_TEXT])
  4513.         {
  4514.             if(Args[ARG_SEND_LITERAL])
  4515.                 SerWrite(Args[ARG_SEND_LITERAL],strlen(Args[ARG_SEND_LITERAL]));
  4516.             else
  4517.                 SerialCommand(Args[ARG_SEND_TEXT]);
  4518.         }
  4519.         else
  4520.         {
  4521.             UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4522.  
  4523.             SerWrite(&Byte,1);
  4524.         }
  4525.  
  4526.         Quiet = FALSE;
  4527.     }
  4528.  
  4529.     return(NULL);
  4530. }
  4531.  
  4532. STRPTR
  4533. RexxSendBreak(struct RexxPkt *Pkt)
  4534. {
  4535.     if(WriteRequest)
  4536.         SendBreak();
  4537.     else
  4538.         Results[0] = RC_WARN;
  4539.  
  4540.     return(NULL);
  4541. }
  4542.  
  4543. STRPTR
  4544. RexxSendFile(struct RexxPkt *Pkt)
  4545. {
  4546.     enum    {    ARG_SENDFILE_MODE,ARG_SENDFILE_NAMES };
  4547.  
  4548.     WORD Mode = TRANSFER_BINARY;
  4549.  
  4550.     if(Args[ARG_SENDFILE_MODE])
  4551.         Mode = ToMode(Args[ARG_SENDFILE_MODE]);
  4552.  
  4553.     if(Mode == -1)
  4554.     {
  4555.         Results[0] = RC_ERROR;
  4556.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  4557.     }
  4558.     else
  4559.     {
  4560.         struct FileTransferInfo    *Info;
  4561.         LONG             FilesFound = 0;
  4562.         UBYTE             LocalBuffer[MAX_FILENAME_LENGTH];
  4563.  
  4564.         Results[0] = RC_OK;
  4565.  
  4566.         if(Info = AllocFileTransferInfo())
  4567.         {
  4568.             struct GenericList *List = GenericListTable[GLIST_UPLOAD];
  4569.  
  4570.             if(Args[ARG_SENDFILE_NAMES])
  4571.             {
  4572.                 struct FileInfoBlock *FileInfo;
  4573.  
  4574.                 if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
  4575.                 {
  4576.                     STRPTR    *Names = (STRPTR *)Args[ARG_SENDFILE_NAMES];
  4577.                     BPTR     FileLock,NewDir,OldDir;
  4578.  
  4579.                     NewDir = NULL;
  4580.  
  4581.                     switch(Mode)
  4582.                     {
  4583.                         case TRANSFER_BINARY:
  4584.  
  4585.                             if(Config -> PathConfig -> BinaryUploadPath[0])
  4586.                                 NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4587.  
  4588.                             break;
  4589.  
  4590.                         case TRANSFER_TEXT:
  4591.  
  4592.                             if(Config -> PathConfig -> TextUploadPath[0])
  4593.                                 NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4594.  
  4595.                             break;
  4596.  
  4597.                         case TRANSFER_ASCII:
  4598.  
  4599.                             if(Config -> PathConfig -> ASCIIUploadPath[0])
  4600.                                 NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4601.  
  4602.                             break;
  4603.                     }
  4604.  
  4605.                     if(NewDir)
  4606.                         OldDir = CurrentDir(NewDir);
  4607.                     else
  4608.                         OldDir = NULL;
  4609.  
  4610.                     while(*Names && Results[0] == RC_OK)
  4611.                     {
  4612.                         if(FileLock = Lock(*Names,ACCESS_READ))
  4613.                         {
  4614.                             if(Examine(FileLock,FileInfo))
  4615.                             {
  4616.                                 if(FileInfo -> fib_DirEntryType < 0)
  4617.                                 {
  4618.                                     if(NameFromLock(FileLock,LocalBuffer,512))
  4619.                                     {
  4620.                                         if(AddFileTransferNode(Info,LocalBuffer,FileInfo -> fib_Size))
  4621.                                             FilesFound++;
  4622.                                         else
  4623.                                         {
  4624.                                             Results[0] = RC_ERROR;
  4625.                                             Results[1] = ERROR_NO_FREE_STORE;
  4626.                                         }
  4627.                                     }
  4628.                                     else
  4629.                                     {
  4630.                                         Results[0] = RC_ERROR;
  4631.                                         Results[1] = IoErr();
  4632.                                     }
  4633.                                 }
  4634.                                 else
  4635.                                 {
  4636.                                     Results[0] = RC_ERROR;
  4637.                                     Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4638.                                 }
  4639.                             }
  4640.                             else
  4641.                             {
  4642.                                 Results[0] = RC_ERROR;
  4643.                                 Results[1] = IoErr();
  4644.                             }
  4645.  
  4646.                             UnLock(FileLock);
  4647.                         }
  4648.                         else
  4649.                         {
  4650.                             Results[0] = RC_ERROR;
  4651.                             Results[1] = IoErr();
  4652.                         }
  4653.  
  4654.                         Names++;
  4655.                     }
  4656.  
  4657.                     if(OldDir)
  4658.                         CurrentDir(OldDir);
  4659.  
  4660.                     if(NewDir)
  4661.                         UnLock(NewDir);
  4662.  
  4663.                     FreeDosObject(DOS_FIB,FileInfo);
  4664.                 }
  4665.                 else
  4666.                 {
  4667.                     Results[0] = RC_ERROR;
  4668.                     Results[1] = ERROR_NO_FREE_STORE;
  4669.                 }
  4670.             }
  4671.  
  4672.             ObtainSemaphore(&List -> ListSemaphore);
  4673.  
  4674.             if(List -> ListHeader . mlh_Head -> mln_Succ && Results[0] == RC_OK)
  4675.             {
  4676.                 struct Node        *Node = (struct Node *)List -> ListHeader . mlh_Head;
  4677.                 struct FileInfoBlock    *FileInfo;
  4678.                 BPTR             NewDir,OldDir;
  4679.  
  4680.                 NewDir = NULL;
  4681.  
  4682.                 switch(Mode)
  4683.                 {
  4684.                     case TRANSFER_BINARY:
  4685.  
  4686.                         if(Config -> PathConfig -> BinaryUploadPath[0])
  4687.                             NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4688.  
  4689.                         break;
  4690.  
  4691.                     case TRANSFER_TEXT:
  4692.  
  4693.                         if(Config -> PathConfig -> TextUploadPath[0])
  4694.                             NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4695.  
  4696.                         break;
  4697.  
  4698.                     case TRANSFER_ASCII:
  4699.  
  4700.                         if(Config -> PathConfig -> ASCIIUploadPath[0])
  4701.                             NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4702.  
  4703.                         break;
  4704.                 }
  4705.  
  4706.                 if(NewDir)
  4707.                     OldDir = CurrentDir(NewDir);
  4708.                 else
  4709.                     OldDir = NULL;
  4710.  
  4711.                 if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
  4712.                 {
  4713.                     BPTR FileLock;
  4714.  
  4715.                     while(Node -> ln_Succ && Results[0] == RC_OK)
  4716.                     {
  4717.                         if(FileLock = Lock(Node -> ln_Name,ACCESS_READ))
  4718.                         {
  4719.                             if(Examine(FileLock,FileInfo))
  4720.                             {
  4721.                                 if(FileInfo -> fib_DirEntryType < 0)
  4722.                                 {
  4723.                                     if(NameFromLock(FileLock,LocalBuffer,512))
  4724.                                     {
  4725.                                         if(AddFileTransferNode(Info,LocalBuffer,FileInfo -> fib_Size))
  4726.                                             FilesFound++;
  4727.                                         else
  4728.                                         {
  4729.                                             Results[0] = RC_ERROR;
  4730.                                             Results[1] = ERROR_NO_FREE_STORE;
  4731.                                         }
  4732.                                     }
  4733.                                     else
  4734.                                     {
  4735.                                         Results[0] = RC_ERROR;
  4736.                                         Results[1] = IoErr();
  4737.                                     }
  4738.                                 }
  4739.                                 else
  4740.                                 {
  4741.                                     Results[0] = RC_ERROR;
  4742.                                     Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4743.                                 }
  4744.                             }
  4745.                             else
  4746.                             {
  4747.                                 Results[0] = RC_ERROR;
  4748.                                 Results[1] = IoErr();
  4749.                             }
  4750.  
  4751.                             UnLock(FileLock);
  4752.                         }
  4753.                         else
  4754.                         {
  4755.                             Results[0] = RC_ERROR;
  4756.                             Results[1] = IoErr();
  4757.                         }
  4758.  
  4759.                         Node = Node -> ln_Succ;
  4760.                     }
  4761.  
  4762.                     if(OldDir)
  4763.                         CurrentDir(OldDir);
  4764.  
  4765.                     if(NewDir)
  4766.                         UnLock(NewDir);
  4767.  
  4768.                     FreeDosObject(DOS_FIB,FileInfo);
  4769.                 }
  4770.                 else
  4771.                 {
  4772.                     Results[0] = RC_ERROR;
  4773.                     Results[1] = ERROR_NO_FREE_STORE;
  4774.                 }
  4775.             }
  4776.  
  4777.             ReleaseSemaphore(&List -> ListSemaphore);
  4778.  
  4779.             if(Results[0] == RC_OK)
  4780.             {
  4781.                 BlockWindows();
  4782.  
  4783.                 if(FilesFound)
  4784.                 {
  4785.                     SortFileTransferInfo(Info);
  4786.  
  4787.                     FileTransferInfo = Info;
  4788.                 }
  4789.  
  4790.                 switch(Mode)
  4791.                 {
  4792.                     case TRANSFER_ASCII:
  4793.  
  4794.                         if(ChangeProtocol(Config -> TransferConfig -> ASCIIUploadLibrary,Config -> TransferConfig -> ASCIIUploadType))
  4795.                         {
  4796.                             BinaryTransfer = FALSE;
  4797.  
  4798.                             if(FilesFound)
  4799.                                 StartXprSendFromList(TRANSFER_ASCII,FALSE);
  4800.                             else
  4801.                                 StartXprSend(TRANSFER_ASCII,FALSE);
  4802.  
  4803.                             BinaryTransfer = TRUE;
  4804.  
  4805.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4806.                         }
  4807.                         else
  4808.                         {
  4809.                             Results[0] = RC_ERROR;
  4810.                             Results[1] = ERROR_NO_FREE_STORE;
  4811.                         }
  4812.  
  4813.                         ResetProtocol();
  4814.  
  4815.                         break;
  4816.  
  4817.                     case TRANSFER_TEXT:
  4818.  
  4819.                         if(ChangeProtocol(Config -> TransferConfig -> TextUploadLibrary,Config -> TransferConfig -> TextUploadType))
  4820.                         {
  4821.                             BinaryTransfer = FALSE;
  4822.  
  4823.                             if(FilesFound)
  4824.                                 StartXprSendFromList(TRANSFER_TEXT,FALSE);
  4825.                             else
  4826.                                 StartXprSend(TRANSFER_TEXT,FALSE);
  4827.  
  4828.                             BinaryTransfer = TRUE;
  4829.  
  4830.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4831.                         }
  4832.                         else
  4833.                         {
  4834.                             Results[0] = RC_ERROR;
  4835.                             Results[1] = ERROR_NO_FREE_STORE;
  4836.                         }
  4837.  
  4838.                         ResetProtocol();
  4839.  
  4840.                         break;
  4841.  
  4842.                     case TRANSFER_BINARY:
  4843.  
  4844.                         if(ChangeProtocol(Config -> TransferConfig -> BinaryUploadLibrary,Config -> TransferConfig -> BinaryUploadType))
  4845.                         {
  4846.                             BinaryTransfer = TRUE;
  4847.  
  4848.                             if(FilesFound)
  4849.                                 StartXprSendFromList(TRANSFER_BINARY,FALSE);
  4850.                             else
  4851.                                 StartXprSend(TRANSFER_BINARY,FALSE);
  4852.  
  4853.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4854.                         }
  4855.                         else
  4856.                         {
  4857.                             Results[0] = RC_ERROR;
  4858.                             Results[1] = ERROR_NO_FREE_STORE;
  4859.                         }
  4860.  
  4861.                         ResetProtocol();
  4862.  
  4863.                         break;
  4864.                 }
  4865.  
  4866.                 if(TransferFailed)
  4867.                     Results[0] = RC_ERROR;
  4868.  
  4869.                 if(TransferAborted)
  4870.                     Results[0] = RC_WARN;
  4871.  
  4872.                 ReleaseWindows();
  4873.             }
  4874.             else
  4875.                 FreeFileTransferInfo(Info);
  4876.         }
  4877.         else
  4878.         {
  4879.             Results[0] = RC_ERROR;
  4880.             Results[1] = ERROR_NO_FREE_STORE;
  4881.         }
  4882.     }
  4883.  
  4884.     return(NULL);
  4885. }
  4886.  
  4887. STRPTR
  4888. RexxSpeak(struct RexxPkt *Pkt)
  4889. {
  4890.     enum    {    ARG_SPEAK_TEXT };
  4891.  
  4892.     if(SpeechConfig . Enabled && English)
  4893.         Say(Args[ARG_SPEAK_TEXT]);
  4894.     else
  4895.         Results[0] = RC_WARN;
  4896.  
  4897.     return(NULL);
  4898. }
  4899.  
  4900. STRPTR
  4901. RexxStopBits(struct RexxPkt *Pkt)
  4902. {
  4903.     enum    {    ARG_STOPBITS_0,ARG_STOPBITS_1 };
  4904.  
  4905.     BYTE Bits;
  4906.  
  4907.     if(Args[ARG_STOPBITS_0])
  4908.         Bits = 0;
  4909.  
  4910.     if(Args[ARG_STOPBITS_1])
  4911.         Bits = 1;
  4912.  
  4913.     if(Config -> SerialConfig -> StopBits != Bits)
  4914.     {
  4915.         Config -> SerialConfig -> StopBits = Bits;
  4916.  
  4917.         UpdateRequired = TRUE;
  4918.  
  4919.         ConfigChanged = TRUE;
  4920.     }
  4921.  
  4922.     return(NULL);
  4923. }
  4924.  
  4925. STRPTR
  4926. RexxTextBuffer(struct RexxPkt *Pkt)
  4927. {
  4928.     enum    {    ARG_TEXTBUFFER_LOCK,ARG_TEXTBUFFER_UNLOCK };
  4929.  
  4930.     Forbid();
  4931.  
  4932.     if(Args[ARG_TEXTBUFFER_LOCK])
  4933.         BufferFrozen = TRUE;
  4934.  
  4935.     if(Args[ARG_TEXTBUFFER_UNLOCK])
  4936.         BufferFrozen = FALSE;
  4937.  
  4938.     CheckItem(MEN_FREEZE_BUFFER,BufferFrozen);
  4939.  
  4940.     ConOutputUpdate();
  4941.  
  4942.     Permit();
  4943.  
  4944.     return(NULL);
  4945. }
  4946.  
  4947. STRPTR
  4948. RexxTimeout(struct RexxPkt *Pkt)
  4949. {
  4950.     enum    {    ARG_TIMEOUT_SECONDS,ARG_TIMEOUT_OFF };
  4951.  
  4952.     if(Args[ARG_TIMEOUT_OFF])
  4953.         RexxTimeoutVal = 0;
  4954.     else
  4955.         RexxTimeoutVal = *(LONG *)Args[ARG_TIMEOUT_SECONDS];
  4956.  
  4957.     return(NULL);
  4958.  
  4959. }
  4960.  
  4961. STRPTR
  4962. RexxTrap(struct RexxPkt *Pkt)
  4963. {
  4964.     enum    {    ARG_TRAP_ON,ARG_TRAP_OFF };
  4965.  
  4966.     BOOLEAN Enabled;
  4967.  
  4968.     Forbid();
  4969.  
  4970.     if(Args[ARG_TRAP_ON])
  4971.         Enabled = TRUE;
  4972.  
  4973.     if(Args[ARG_TRAP_OFF])
  4974.         Enabled = FALSE;
  4975.  
  4976.     CheckItem(MEN_DISABLE_TRAPS,Enabled ^ TRUE);
  4977.  
  4978.     Permit();
  4979.  
  4980.     ObtainSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4981.  
  4982.     if(GenericListTable[GLIST_TRAP] -> ListHeader . mlh_Head -> mln_Succ && Enabled)
  4983.         WatchTraps = TRUE;
  4984.     else
  4985.         WatchTraps = FALSE;
  4986.  
  4987.     ReleaseSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4988.  
  4989.     return(NULL);
  4990. }
  4991.  
  4992. STATIC STRPTR         RexxWaitResult;
  4993. STATIC struct WaitNode    *RexxWaitNode;
  4994.  
  4995. STATIC BOOLEAN
  4996. RexxWaitBypass(STRPTR Buffer,LONG Size)
  4997. {
  4998.     LONG Position;
  4999.  
  5000.     RexxWaitResult = ScanNodeFilter(Buffer,Size,RexxWaitNode,&Position);
  5001.  
  5002.     SerWriteVerbatim(Buffer,Size,FALSE);
  5003.  
  5004.     return(FALSE);
  5005. }
  5006.  
  5007. STRPTR
  5008. RexxWait(struct RexxPkt *Pkt)
  5009. {
  5010.     enum    {    ARG_WAIT_NOECHO,ARG_WAIT_TEXT };
  5011.  
  5012.     ULONG         Signals;
  5013.     STRPTR         Result = NULL;
  5014.     BYTE         Echo;
  5015.     struct WaitNode    *WaitNode,
  5016.              Node;
  5017.     UBYTE         DummyBuffer[256];
  5018.     LONG         Position;
  5019.     struct List     DummyList;
  5020.  
  5021.     if(!ReadRequest || !WriteRequest)
  5022.     {
  5023.         Results[0] = RC_WARN;
  5024.  
  5025.         return(NULL);
  5026.     }
  5027.  
  5028.     if(Args[ARG_WAIT_NOECHO])
  5029.         Echo = FALSE;
  5030.     else
  5031.         Echo = TRUE;
  5032.  
  5033.     if(Args[ARG_WAIT_TEXT])
  5034.     {
  5035.         WORD i,Len;
  5036.  
  5037.         NewList(&DummyList);
  5038.  
  5039.         memcpy(DummyBuffer,Args[ARG_WAIT_TEXT],255);
  5040.  
  5041.         DummyBuffer[255] = 0;
  5042.  
  5043.         for(i = 0 ; i < strlen(DummyBuffer) ; i++)
  5044.             DummyBuffer[i] = ToUpper(DummyBuffer[i]);
  5045.  
  5046.         Len = TranslateString(DummyBuffer,DummyBuffer);
  5047.  
  5048.         DummyBuffer[Len] = 0;
  5049.  
  5050.         memset(&Node,0,sizeof(struct WaitNode));
  5051.  
  5052.         Node . Node . ln_Name    = DummyBuffer;
  5053.         Node . Count        = 0;
  5054.  
  5055.         WaitNode = &Node;
  5056.  
  5057.         AddTail(&DummyList,(struct Node *)WaitNode);
  5058.     }
  5059.     else
  5060.     {
  5061.         if(!GenericListCount(GenericListTable[GLIST_WAIT]))
  5062.         {
  5063.             Results[0] = RC_ERROR;
  5064.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  5065.  
  5066.             return(NULL);
  5067.         }
  5068.         else
  5069.         {
  5070.             WaitNode = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  5071.  
  5072.             while(WaitNode -> Node . ln_Succ)
  5073.             {
  5074.                 WaitNode -> Count = 0;
  5075.  
  5076.                 WaitNode = (struct WaitNode *)WaitNode -> Node . ln_Succ;
  5077.             }
  5078.  
  5079.             WaitNode = NULL;
  5080.         }
  5081.     }
  5082.  
  5083.     if(RexxTimeoutVal)
  5084.         StartTime(RexxTimeoutVal,0);
  5085.  
  5086.     WaitCount = 0;
  5087.  
  5088.     BlockWindows();
  5089.  
  5090.     Forbid();
  5091.  
  5092.     LT_UnlockWindow(Window);
  5093.  
  5094.     Window -> Flags |= WFLG_RMBTRAP;
  5095.  
  5096.     Permit();
  5097.  
  5098.     if(Marking)
  5099.         DropMarker();
  5100.  
  5101.     NormalCursor();
  5102.  
  5103.     if(DataHold)
  5104.     {
  5105.         if(Echo)
  5106.         {
  5107.             ConProcess(DataHold,DataSize);
  5108.  
  5109.             Status = STATUS_READY;
  5110.         }
  5111.  
  5112.         if(Result = ScanNodeFilter(DataHold,DataSize,WaitNode,&Position))
  5113.         {
  5114.             if(Position < DataSize)
  5115.             {
  5116.                 DataHold += Position;
  5117.                 DataSize -= Position;
  5118.             }
  5119.             else
  5120.             {
  5121.                 DataHold = NULL;
  5122.  
  5123.                 RestartSerial(TRUE);
  5124.             }
  5125.         }
  5126.         else
  5127.         {
  5128.             DataHold = NULL;
  5129.  
  5130.             RestartSerial(TRUE);
  5131.         }
  5132.     }
  5133.  
  5134.     if(!Result)
  5135.     {
  5136.         if(CheckSerialRead())
  5137.             Signals = SIG_SERIAL;
  5138.         else
  5139.             Signals = NULL;
  5140.  
  5141.         do
  5142.         {
  5143.             if(Signals & SIG_WINDOW)
  5144.             {
  5145.                 if(!Result)
  5146.                 {
  5147.                     SerWriteBypass = RexxWaitBypass;
  5148.  
  5149.                     RexxWaitResult    = Result;
  5150.                     RexxWaitNode    = WaitNode;
  5151.  
  5152.                     while(HandleWindow());
  5153.  
  5154.                     Result = RexxWaitResult;
  5155.  
  5156.                     SerWriteBypass = NULL;
  5157.                 }
  5158.             }
  5159.  
  5160.             if(Signals & SIG_SERIAL)
  5161.             {
  5162.                 BOOLEAN Restart = TRUE;
  5163.  
  5164.                 if(!WaitSerialRead())
  5165.                 {
  5166.                     LONG Length;
  5167.  
  5168.                     BytesIn++;
  5169.  
  5170.                     if(Translate_CR_LF)
  5171.                         Length = (*Translate_CR_LF)(ReadBuffer,1);
  5172.                     else
  5173.                         Length = 1;
  5174.  
  5175.                     if(Echo && Length)
  5176.                     {
  5177.                         ConProcess(ReadBuffer,Length);
  5178.  
  5179.                         Status = STATUS_READY;
  5180.                     }
  5181.  
  5182.                     if(!Result && Length)
  5183.                         Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position);
  5184.  
  5185.                     if(!Result)
  5186.                     {
  5187.                             /* Check how many bytes are still in
  5188.                              * the serial buffer.
  5189.                              */
  5190.  
  5191.                         if(Length = GetSerialWaiting())
  5192.                         {
  5193.                             if(Length > SerialBufferSize)
  5194.                                 Length = SerialBufferSize;
  5195.  
  5196.                             if(Length > Config -> SerialConfig -> Quantum)
  5197.                                 Length = Config -> SerialConfig -> Quantum;
  5198.  
  5199.                             if(!DoSerialRead(ReadBuffer,Length))
  5200.                             {
  5201.                                 BytesIn += Length;
  5202.  
  5203.                                 if(Translate_CR_LF)
  5204.                                     Length = (* Translate_CR_LF)(ReadBuffer,Length);
  5205.  
  5206.                                 if(Length)
  5207.                                 {
  5208.                                         /* Send the data to the console. */
  5209.  
  5210.                                     if(Echo)
  5211.                                     {
  5212.                                         ConProcess(ReadBuffer,Length);
  5213.  
  5214.                                         Status = STATUS_READY;
  5215.                                     }
  5216.  
  5217.                                     if(Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position))
  5218.                                     {
  5219.                                         if(Position < Length)
  5220.                                         {
  5221.                                             DataHold = (UBYTE *)ReadBuffer    + Position;
  5222.                                             DataSize = Length        - Position;
  5223.  
  5224.                                             Restart = FALSE;
  5225.                                         }
  5226.                                         else
  5227.                                             DataHold = NULL;
  5228.                                     }
  5229.                                 }
  5230.                             }
  5231.                         }
  5232.                     }
  5233.                 }
  5234.  
  5235.                 if(Restart)
  5236.                     RestartSerial(TRUE);
  5237.             }
  5238.  
  5239.             if(Signals & (SIG_BREAK | SIG_TIMER))
  5240.             {
  5241.                 if(!Result)
  5242.                     Results[0] = RC_WARN;
  5243.  
  5244.                 break;
  5245.             }
  5246.  
  5247.             if(!Result)
  5248.                 Signals = Wait(SIG_SERIAL | SIG_TIMER | SIG_BREAK | SIG_WINDOW);
  5249.         }
  5250.         while(!Result);
  5251.     }
  5252.  
  5253.     Forbid();
  5254.  
  5255.     Window -> Flags &= ~WFLG_RMBTRAP;
  5256.  
  5257.     LT_LockWindow(Window);
  5258.  
  5259.     Permit();
  5260.  
  5261.     ReleaseWindows();
  5262.  
  5263.     if(RexxTimeoutVal)
  5264.         StopTime();
  5265.  
  5266.     if(Result)
  5267.         return(CreateResult(Result,Results));
  5268.     else
  5269.         return(NULL);
  5270. }
  5271.  
  5272. STRPTR
  5273. RexxWindow(struct RexxPkt *Pkt)
  5274. {
  5275.     enum    {    ARG_WINDOW_NAMES,ARG_WINDOW_OPEN,ARG_WINDOW_CLOSE,ARG_WINDOW_ACTIVATE,
  5276.             ARG_WINDOW_MIN,ARG_WINDOW_MAX,ARG_WINDOW_FRONT,ARG_WINDOW_BACK,
  5277.             ARG_WINDOW_TOP,ARG_WINDOW_BOTTOM,ARG_WINDOW_UP,ARG_WINDOW_DOWN };
  5278.  
  5279.     STRPTR    *Names = (STRPTR *)Args[ARG_WINDOW_NAMES];
  5280.     WORD     Index;
  5281.  
  5282.     while(*Names)
  5283.     {
  5284.         if((Index = ToWindow(*Names++)) != -1)
  5285.         {
  5286.             if(Args[ARG_WINDOW_OPEN])
  5287.             {
  5288.                 Forbid();
  5289.  
  5290.                 switch(Index)
  5291.                 {
  5292.                     case WINDOWID_BUFFER:
  5293.  
  5294.                         ObtainSemaphore(&BufferTaskSemaphore);
  5295.  
  5296.                         if(!BufferTask)
  5297.                         {
  5298.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5299.  
  5300.                             LaunchBuffer();
  5301.                         }
  5302.                         else
  5303.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5304.  
  5305.                         break;
  5306.  
  5307.                     case WINDOWID_UPLOAD_QUEUE:
  5308.  
  5309.                         CreateQueueProcess();
  5310.  
  5311.                         break;
  5312.  
  5313.                     case WINDOWID_REVIEW:
  5314.  
  5315.                         if(!ReviewWindow)
  5316.                             CreateReview();
  5317.  
  5318.                         break;
  5319.  
  5320.                     case WINDOWID_PACKET:
  5321.  
  5322.                         if(!PacketWindow)
  5323.                             CreatePacketWindow();
  5324.  
  5325.                         break;
  5326.  
  5327.                     case WINDOWID_FASTMACROS:
  5328.  
  5329.                         if(!FastWindow)
  5330.                             OpenFastWindow();
  5331.  
  5332.                         break;
  5333.  
  5334.                     case WINDOWID_STATUS:
  5335.  
  5336.                         if(!InfoWindow)
  5337.                             OpenInfoWindow();
  5338.  
  5339.                         break;
  5340.  
  5341.                     case WINDOWID_MAIN:
  5342.  
  5343.                         if(!IconTerminated)
  5344.                             IconTerminated = TRUE;
  5345.  
  5346.                         break;
  5347.                 }
  5348.  
  5349.                 Permit();
  5350.             }
  5351.  
  5352.             if(Args[ARG_WINDOW_CLOSE])
  5353.             {
  5354.                 Forbid();
  5355.  
  5356.                 switch(Index)
  5357.                 {
  5358.                     case WINDOWID_UPLOAD_QUEUE:
  5359.  
  5360.                         CloseQueueWindow();
  5361.                         break;
  5362.  
  5363.                     case WINDOWID_BUFFER:
  5364.  
  5365.                         ObtainSemaphore(&BufferTaskSemaphore);
  5366.  
  5367.                         if(BufferTask)
  5368.                         {
  5369.                             Signal(BufferTask,SIG_KILL);
  5370.  
  5371.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5372.  
  5373.                             ClrSignal(SIG_HANDSHAKE);
  5374.  
  5375.                             Wait(SIG_HANDSHAKE);
  5376.                         }
  5377.                         else
  5378.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5379.  
  5380.                         break;
  5381.  
  5382.                     case WINDOWID_REVIEW:
  5383.  
  5384.                         if(ReviewWindow)
  5385.                             DeleteReview();
  5386.  
  5387.                         break;
  5388.  
  5389.                     case WINDOWID_PACKET:
  5390.  
  5391.                         if(PacketWindow)
  5392.                             DeletePacketWindow(FALSE);
  5393.  
  5394.                         break;
  5395.  
  5396.                     case WINDOWID_FASTMACROS:
  5397.  
  5398.                         if(FastWindow)
  5399.                             CloseFastWindow();
  5400.  
  5401.                         break;
  5402.  
  5403.                     case WINDOWID_STATUS:
  5404.  
  5405.                         if(InfoWindow)
  5406.                             CloseInfoWindow();
  5407.  
  5408.                         break;
  5409.  
  5410.                     case WINDOWID_MAIN:
  5411.  
  5412.                         if(Window)
  5413.                             DoIconify = TRUE;
  5414.  
  5415.                         break;
  5416.                 }
  5417.  
  5418.                 Permit();
  5419.             }
  5420.  
  5421.             if(Args[ARG_WINDOW_ACTIVATE])
  5422.             {
  5423.                 Forbid();
  5424.  
  5425.                 switch(Index)
  5426.                 {
  5427.                     case WINDOWID_UPLOAD_QUEUE:
  5428.  
  5429.                         CreateQueueProcess();
  5430.  
  5431.                         break;
  5432.  
  5433.                     case WINDOWID_BUFFER:
  5434.  
  5435.                         ObtainSemaphore(&BufferTaskSemaphore);
  5436.  
  5437.                         if(BufferTask)
  5438.                         {
  5439.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5440.  
  5441.                             LaunchBuffer();
  5442.                         }
  5443.                         else
  5444.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5445.  
  5446.                         break;
  5447.  
  5448.                     case WINDOWID_REVIEW:
  5449.  
  5450.                         if(ReviewWindow)
  5451.                             BumpWindow(ReviewWindow);
  5452.  
  5453.                         break;
  5454.  
  5455.                     case WINDOWID_PACKET:
  5456.  
  5457.                         if(PacketWindow)
  5458.                             BumpWindow(PacketWindow);
  5459.  
  5460.                         break;
  5461.  
  5462.                     case WINDOWID_FASTMACROS:
  5463.  
  5464.                         if(FastWindow)
  5465.                             BumpWindow(FastWindow);
  5466.  
  5467.                         break;
  5468.  
  5469.                     case WINDOWID_STATUS:
  5470.  
  5471.                         if(InfoWindow)
  5472.                             BumpWindow(InfoWindow);
  5473.  
  5474.                         break;
  5475.  
  5476.                     case WINDOWID_MAIN:
  5477.  
  5478.                         if(Window)
  5479.                             BumpWindow(Window);
  5480.  
  5481.                         break;
  5482.                 }
  5483.  
  5484.                 Permit();
  5485.             }
  5486.  
  5487.             if(Args[ARG_WINDOW_MIN])
  5488.             {
  5489.                 struct Window *SomeWindow = NULL;
  5490.  
  5491.                 Forbid();
  5492.  
  5493.                 switch(Index)
  5494.                 {
  5495.                     case WINDOWID_REVIEW:
  5496.  
  5497.                         SomeWindow = ReviewWindow;
  5498.                         break;
  5499.  
  5500.                     case WINDOWID_PACKET:
  5501.  
  5502.                         SomeWindow = PacketWindow;
  5503.                         break;
  5504.  
  5505.                     case WINDOWID_FASTMACROS:
  5506.  
  5507.                         SomeWindow = FastWindow;
  5508.                         break;
  5509.  
  5510.                     case WINDOWID_STATUS:
  5511.  
  5512.                         SomeWindow = InfoWindow;
  5513.                         break;
  5514.                 }
  5515.  
  5516.                 if(SomeWindow)
  5517.                     ChangeWindowBox(SomeWindow,SomeWindow -> LeftEdge,SomeWindow -> TopEdge,SomeWindow -> MinWidth,SomeWindow -> MinHeight);
  5518.  
  5519.                 Permit();
  5520.             }
  5521.  
  5522.             if(Args[ARG_WINDOW_MAX])
  5523.             {
  5524.                 struct Window *SomeWindow = NULL;
  5525.  
  5526.                 Forbid();
  5527.  
  5528.                 switch(Index)
  5529.                 {
  5530.                     case WINDOWID_REVIEW:
  5531.  
  5532.                         SomeWindow = ReviewWindow;
  5533.                         break;
  5534.  
  5535.                     case WINDOWID_PACKET:
  5536.  
  5537.                         SomeWindow = PacketWindow;
  5538.                         break;
  5539.  
  5540.                     case WINDOWID_FASTMACROS:
  5541.  
  5542.                         SomeWindow = FastWindow;
  5543.                         break;
  5544.  
  5545.                     case WINDOWID_STATUS:
  5546.  
  5547.                         SomeWindow = InfoWindow;
  5548.                         break;
  5549.                 }
  5550.  
  5551.                 if(SomeWindow)
  5552.                     ChangeWindowBox(SomeWindow,0,0,SomeWindow -> MaxWidth,SomeWindow -> MaxHeight);
  5553.  
  5554.                 Permit();
  5555.             }
  5556.  
  5557.             if(Args[ARG_WINDOW_FRONT])
  5558.             {
  5559.                 Forbid();
  5560.  
  5561.                 switch(Index)
  5562.                 {
  5563.                     case WINDOWID_UPLOAD_QUEUE:
  5564.  
  5565.                         CreateQueueProcess();
  5566.  
  5567.                         break;
  5568.  
  5569.                     case WINDOWID_BUFFER:
  5570.  
  5571.                         ObtainSemaphore(&BufferTaskSemaphore);
  5572.  
  5573.                         if(BufferTask)
  5574.                         {
  5575.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5576.  
  5577.                             LaunchBuffer();
  5578.                         }
  5579.                         else
  5580.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5581.  
  5582.                         break;
  5583.  
  5584.                     case WINDOWID_REVIEW:
  5585.  
  5586.                         if(ReviewWindow)
  5587.                             WindowToFront(ReviewWindow);
  5588.  
  5589.                         break;
  5590.  
  5591.                     case WINDOWID_PACKET:
  5592.  
  5593.                         if(PacketWindow)
  5594.                             WindowToFront(PacketWindow);
  5595.  
  5596.                         break;
  5597.  
  5598.                     case WINDOWID_FASTMACROS:
  5599.  
  5600.                         if(FastWindow)
  5601.                             WindowToFront(FastWindow);
  5602.  
  5603.                         break;
  5604.  
  5605.                     case WINDOWID_STATUS:
  5606.  
  5607.                         if(InfoWindow)
  5608.                             WindowToFront(InfoWindow);
  5609.  
  5610.                         break;
  5611.  
  5612.                     case WINDOWID_MAIN:
  5613.  
  5614.                         if(Window)
  5615.                             WindowToFront(Window);
  5616.  
  5617.                         break;
  5618.                 }
  5619.  
  5620.                 Permit();
  5621.             }
  5622.  
  5623.             if(Args[ARG_WINDOW_BACK])
  5624.             {
  5625.                 Forbid();
  5626.  
  5627.                 switch(Index)
  5628.                 {
  5629.                     case WINDOWID_REVIEW:
  5630.  
  5631.                         if(ReviewWindow)
  5632.                             WindowToBack(ReviewWindow);
  5633.  
  5634.                         break;
  5635.  
  5636.                     case WINDOWID_PACKET:
  5637.  
  5638.                         if(PacketWindow)
  5639.                             WindowToBack(PacketWindow);
  5640.  
  5641.                         break;
  5642.  
  5643.                     case WINDOWID_FASTMACROS:
  5644.  
  5645.                         if(FastWindow)
  5646.                             WindowToBack(FastWindow);
  5647.  
  5648.                         break;
  5649.  
  5650.                     case WINDOWID_STATUS:
  5651.  
  5652.                         if(InfoWindow)
  5653.                             WindowToBack(InfoWindow);
  5654.  
  5655.                         break;
  5656.  
  5657.                     case WINDOWID_MAIN:
  5658.  
  5659.                         if(Window)
  5660.                             WindowToBack(Window);
  5661.  
  5662.                         break;
  5663.                 }
  5664.  
  5665.                 Permit();
  5666.             }
  5667.  
  5668.             Forbid();
  5669.  
  5670.             if(Index == WINDOW_REVIEW && ReviewWindow)
  5671.             {
  5672.                 if(Args[ARG_WINDOW_TOP])
  5673.                     MoveReview(REVIEW_MOVE_TOP);
  5674.  
  5675.                 if(Args[ARG_WINDOW_BOTTOM])
  5676.                     MoveReview(REVIEW_MOVE_BOTTOM);
  5677.  
  5678.                 if(Args[ARG_WINDOW_UP])
  5679.                     MoveReview(REVIEW_MOVE_UP);
  5680.  
  5681.                 if(Args[ARG_WINDOW_DOWN])
  5682.                     MoveReview(REVIEW_MOVE_DOWN);
  5683.             }
  5684.  
  5685.             Permit();
  5686.         }
  5687.     }
  5688.  
  5689.     return(NULL);
  5690. }
  5691.  
  5692. STRPTR
  5693. RexxRX(struct RexxPkt *Pkt)
  5694. {
  5695.     enum    {    ARG_RX_CONSOLE,ARG_RX_ASYNC,ARG_RX_COMMAND };
  5696.  
  5697.     struct MsgPort    *RexxPort;
  5698.     BYTE         Eaten = FALSE;
  5699.  
  5700.     if(RexxPort = FindPort(RXSDIR))
  5701.     {
  5702.         struct MsgPort __aligned     SinglePort;
  5703.         struct RexxMsg            *HostMessage;
  5704.  
  5705.         InitSinglePort(&SinglePort);
  5706.  
  5707.         if(HostMessage = CreateRexxMsg(&SinglePort,"term",RexxPortName))
  5708.         {
  5709.             if(HostMessage -> rm_Args[0] = CreateArgstring(Args[ARG_RX_COMMAND],strlen(Args[ARG_RX_COMMAND])))
  5710.             {
  5711.                 HostMessage -> rm_Action = RXCOMM;
  5712.  
  5713.                 if(!GoodStream(NULL))
  5714.                     HostMessage -> rm_Action |= RXFF_NOIO;
  5715.  
  5716.                 if(Args[ARG_RX_ASYNC])
  5717.                 {
  5718.                     RexxPktCleanup(Pkt,NULL);
  5719.  
  5720.                     Eaten = TRUE;
  5721.                 }
  5722.  
  5723.                 Forbid();
  5724.  
  5725.                 PutMsg(RexxPort,HostMessage);
  5726.  
  5727.                 ClrSignal(SIGF_SINGLE);
  5728.  
  5729.                 WaitPort(&SinglePort);
  5730.  
  5731.                 Permit();
  5732.  
  5733.                 GetMsg(&SinglePort);
  5734.  
  5735.                 if(!Eaten)
  5736.                 {
  5737.                     Results[0] = HostMessage -> rm_Result1;
  5738.                     Results[1] = HostMessage -> rm_Result2;
  5739.                 }
  5740.             }
  5741.             else
  5742.             {
  5743.                 Results[0] = RC_ERROR;
  5744.                 Results[1] = ERR10_003;
  5745.             }
  5746.  
  5747.             DeleteRexxMsg(HostMessage);
  5748.         }
  5749.         else
  5750.         {
  5751.             Results[0] = RC_ERROR;
  5752.             Results[1] = ERR10_003;
  5753.         }
  5754.     }
  5755.     else
  5756.     {
  5757.         Results[0] = RC_ERROR;
  5758.         Results[1] = ERR10_013;
  5759.     }
  5760.  
  5761.     if(!Eaten)
  5762.         RexxPktCleanup(Pkt,NULL);
  5763.  
  5764.     return(NULL);
  5765. }
  5766.  
  5767. STRPTR
  5768. RexxExecTool(struct RexxPkt *Pkt)
  5769. {
  5770.     enum    {    ARG_EXECTOOL_CONSOLE,ARG_EXECTOOL_ASYNC,ARG_EXECTOOL_PORT,ARG_EXECTOOL_COMMAND };
  5771.  
  5772.     LONG     Error;
  5773.     UBYTE     CommandName[256],
  5774.          CommandArgs[256],
  5775.         *Index = Args[ARG_EXECTOOL_COMMAND];
  5776.     WORD     i;
  5777.     BYTE     Eaten = FALSE;
  5778.  
  5779.     while(*Index == ' ' || *Index == '\t')
  5780.         Index++;
  5781.  
  5782.     for(i = 0 ; Index[i] != ' ' && Index[i] != '\t' ; i++)
  5783.         CommandName[i] = Index[i];
  5784.  
  5785.     CommandName[i] = 0;
  5786.  
  5787.     Index += i;
  5788.  
  5789.     while(*Index == ' ' || *Index == '\t')
  5790.         Index++;
  5791.  
  5792.     if(Args[ARG_EXECTOOL_PORT])
  5793.         SPrintf(CommandArgs,"%s %s\n",Index,RexxPortName);
  5794.     else
  5795.         SPrintf(CommandArgs,"%s\n",Index);
  5796.  
  5797.     if(Args[ARG_EXECTOOL_ASYNC])
  5798.     {
  5799.         RexxPktCleanup(Pkt,NULL);
  5800.  
  5801.         Eaten = TRUE;
  5802.     }
  5803.  
  5804.     Error = SystemTags(CommandName,
  5805.         NP_Arguments,    CommandArgs,
  5806.         SYS_UserShell,    TRUE,
  5807.     TAG_DONE);
  5808.  
  5809.     if(!Eaten)
  5810.     {
  5811.         if(Error)
  5812.         {
  5813.             Results[0] = RC_ERROR;
  5814.             Results[1] = Error;
  5815.         }
  5816.  
  5817.         RexxPktCleanup(Pkt,NULL);
  5818.     }
  5819.  
  5820.     return(NULL);
  5821. }
  5822.